* OpenACC 2.5 Profiling Interface (incomplete)
@ 2017-02-28 17:54 Thomas Schwinge
2017-05-15 7:38 ` More OpenACC 2.5 Profiling Interface (was: OpenACC 2.5 Profiling Interface (incomplete)) Thomas Schwinge
` (2 more replies)
0 siblings, 3 replies; 23+ messages in thread
From: Thomas Schwinge @ 2017-02-28 17:54 UTC (permalink / raw)
To: gcc-patches; +Cc: Cesar Philippidis
Hi!
The 2.5 versions of the OpenACC standard added a new chapter "Profiling
Interface". In r245784, I committed incomplete support to
gomp-4_0-branch. I plan to continue working on this, but wanted to
synchronize at this point.
commit b22a85fe7f3daeb48460e7aa28606d0cdb799f69
Author: tschwinge <tschwinge@138bc75d-0d04-0410-961f-82ee72b054a4>
Date: Tue Feb 28 17:36:03 2017 +0000
OpenACC 2.5 Profiling Interface (incomplete)
libgomp/
* acc_prof.h: New file.
* oacc-profiling-acc_register_library.c: Likewise.
* oacc-profiling.c: Likewise.
* Makefile.am (nodist_libsubinclude_HEADERS, libgomp_la_SOURCES):
Add these, respectively.
* Makefile.in: Regenerate.
* libgomp/config/nvptx/oacc-profiling-acc_register_library.c:
New empty file.
* libgomp/config/nvptx/oacc-profiling.c: Likewise.
* env.c (initialize_env): Call goacc_profiling_initialize.
* libgomp-plugin.c: New function
GOMP_PLUGIN_goacc_profiling_dispatch.
* libgomp-plugin.h: Declare function
GOMP_PLUGIN_goacc_profiling_dispatch.
* oacc-plugin.c: New function GOMP_PLUGIN_goacc_thread.
* oacc-plugin.h: Declare function GOMP_PLUGIN_goacc_thread.
* libgomp.map (OACC_2.5): Add acc_prof_lookup, acc_prof_register,
acc_prof_unregister, and acc_register_library.
Add GOMP_PLUGIN_goacc_profiling_dispatch, and
GOMP_PLUGIN_goacc_thread with new GOMP_PLUGIN_1.3 symbol version.
* oacc-int.h (struct goacc_thread): Add "acc_prof_info
*prof_info", "acc_api_info *api_info", and "bool
prof_callbacks_enabled" members.
Declare functions goacc_profiling_initialize,
goacc_profiling_dispatch_p, and goacc_profiling_dispatch.
* oacc-init.c (acc_init_1): Add "acc_construct_t", and "int"
formal parameters. Adjust all users.
(acc_init_1, goacc_attach_host_thread_to_device, acc_init)
(goacc_lazy_initialize): Update for OpenACC Profiling Interface.
* oacc-parallel.c (GOACC_parallel_keyed): Likewise.
* plugin/plugin-nvptx.c (cuda_map_create, cuda_map_destroy)
(map_init, map_fini, map_pop, map_push): Add "struct goacc_thread
*" formal parameter. Adjust all users.
(select_stream_for_async, event_gc, nvptx_exec, nvptx_host2dev)
(nvptx_dev2host, nvptx_set_cuda_stream): Call
GOMP_PLUGIN_goacc_thread instead of nvptx_thread.
(cuda_map_create, cuda_map_destroy, nvptx_exec, nvptx_alloc)
(nvptx_free, nvptx_host2dev, nvptx_dev2host): Update for OpenACC
Profiling Interface.
* libgomp.texi: New chapter "OpenACC Profiling Interface".
* testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c: New
file.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c: Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c:
Likewise.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/gomp-4_0-branch@245784 138bc75d-0d04-0410-961f-82ee72b054a4
---
libgomp/ChangeLog.gomp | 50 ++
libgomp/Makefile.am | 5 +-
libgomp/Makefile.in | 10 +-
libgomp/acc_prof.h | 237 +++++++
.../nvptx/oacc-profiling-acc_register_library.c | 0
libgomp/config/nvptx/oacc-profiling.c | 0
libgomp/env.c | 3 +-
libgomp/libgomp-plugin.c | 9 +
libgomp/libgomp-plugin.h | 6 +
libgomp/libgomp.map | 11 +
libgomp/libgomp.texi | 246 +++++++
libgomp/oacc-init.c | 68 +-
libgomp/oacc-int.h | 12 +
libgomp/oacc-parallel.c | 126 +++-
libgomp/oacc-plugin.c | 13 +
libgomp/oacc-plugin.h | 3 +
...gin.h => oacc-profiling-acc_register_library.c} | 19 +-
libgomp/oacc-profiling.c | 576 +++++++++++++++++
libgomp/plugin/plugin-nvptx.c | 315 ++++++++-
.../acc_prof-dispatch-1.c | 344 ++++++++++
.../libgomp.oacc-c-c++-common/acc_prof-init-1.c | 306 +++++++++
.../acc_prof-parallel-1.c | 703 +++++++++++++++++++++
.../acc_prof-valid_bytes-1.c | 172 +++++
.../libgomp.oacc-c-c++-common/acc_prof-version-1.c | 55 ++
24 files changed, 3243 insertions(+), 46 deletions(-)
diff --git libgomp/ChangeLog.gomp libgomp/ChangeLog.gomp
index af6a28b..acdb004 100644
--- libgomp/ChangeLog.gomp
+++ libgomp/ChangeLog.gomp
@@ -1,5 +1,55 @@
2017-02-28 Thomas Schwinge <thomas@codesourcery.com>
+ * acc_prof.h: New file.
+ * oacc-profiling-acc_register_library.c: Likewise.
+ * oacc-profiling.c: Likewise.
+ * Makefile.am (nodist_libsubinclude_HEADERS, libgomp_la_SOURCES):
+ Add these, respectively.
+ * Makefile.in: Regenerate.
+ * libgomp/config/nvptx/oacc-profiling-acc_register_library.c:
+ New empty file.
+ * libgomp/config/nvptx/oacc-profiling.c: Likewise.
+ * env.c (initialize_env): Call goacc_profiling_initialize.
+ * libgomp-plugin.c: New function
+ GOMP_PLUGIN_goacc_profiling_dispatch.
+ * libgomp-plugin.h: Declare function
+ GOMP_PLUGIN_goacc_profiling_dispatch.
+ * oacc-plugin.c: New function GOMP_PLUGIN_goacc_thread.
+ * oacc-plugin.h: Declare function GOMP_PLUGIN_goacc_thread.
+ * libgomp.map (OACC_2.5): Add acc_prof_lookup, acc_prof_register,
+ acc_prof_unregister, and acc_register_library.
+ Add GOMP_PLUGIN_goacc_profiling_dispatch, and
+ GOMP_PLUGIN_goacc_thread with new GOMP_PLUGIN_1.3 symbol version.
+ * oacc-int.h (struct goacc_thread): Add "acc_prof_info
+ *prof_info", "acc_api_info *api_info", and "bool
+ prof_callbacks_enabled" members.
+ Declare functions goacc_profiling_initialize,
+ goacc_profiling_dispatch_p, and goacc_profiling_dispatch.
+ * oacc-init.c (acc_init_1): Add "acc_construct_t", and "int"
+ formal parameters. Adjust all users.
+ (acc_init_1, goacc_attach_host_thread_to_device, acc_init)
+ (goacc_lazy_initialize): Update for OpenACC Profiling Interface.
+ * oacc-parallel.c (GOACC_parallel_keyed): Likewise.
+ * plugin/plugin-nvptx.c (cuda_map_create, cuda_map_destroy)
+ (map_init, map_fini, map_pop, map_push): Add "struct goacc_thread
+ *" formal parameter. Adjust all users.
+ (select_stream_for_async, event_gc, nvptx_exec, nvptx_host2dev)
+ (nvptx_dev2host, nvptx_set_cuda_stream): Call
+ GOMP_PLUGIN_goacc_thread instead of nvptx_thread.
+ (cuda_map_create, cuda_map_destroy, nvptx_exec, nvptx_alloc)
+ (nvptx_free, nvptx_host2dev, nvptx_dev2host): Update for OpenACC
+ Profiling Interface.
+ * libgomp.texi: New chapter "OpenACC Profiling Interface".
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c: New
+ file.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c: Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c:
+ Likewise.
+
* oacc-init.c (goacc_register, acc_init, goacc_lazy_initialize):
Fix locking of cached_base_dev (guarded by acc_device_lock).
(goacc_lazy_initialize): Don't call acc_init; copy code here,
diff --git libgomp/Makefile.am libgomp/Makefile.am
index a3e1c2b..9a75c48 100644
--- libgomp/Makefile.am
+++ libgomp/Makefile.am
@@ -63,7 +63,8 @@ libgomp_la_SOURCES = alloc.c barrier.c critical.c env.c error.c iter.c \
task.c team.c work.c lock.c mutex.c proc.c sem.c bar.c ptrlock.c \
time.c fortran.c affinity.c target.c splay-tree.c libgomp-plugin.c \
oacc-parallel.c oacc-host.c oacc-init.c oacc-mem.c oacc-async.c \
- oacc-plugin.c oacc-cuda.c priority_queue.c
+ oacc-plugin.c oacc-cuda.c priority_queue.c \
+ oacc-profiling.c oacc-profiling-acc_register_library.c
include $(top_srcdir)/plugin/Makefrag.am
@@ -72,7 +73,7 @@ libgomp_la_SOURCES += openacc.f90
endif
nodist_noinst_HEADERS = libgomp_f.h
-nodist_libsubinclude_HEADERS = omp.h openacc.h
+nodist_libsubinclude_HEADERS = acc_prof.h omp.h openacc.h
if USE_FORTRAN
nodist_finclude_HEADERS = omp_lib.h omp_lib.f90 omp_lib.mod omp_lib_kinds.mod \
openacc_lib.h openacc.f90 openacc.mod openacc_kinds.mod
diff --git libgomp/Makefile.in libgomp/Makefile.in
index 88c8517..dac2b4e 100644
--- libgomp/Makefile.in
+++ libgomp/Makefile.in
@@ -180,7 +180,8 @@ am_libgomp_la_OBJECTS = alloc.lo barrier.lo critical.lo env.lo \
fortran.lo affinity.lo target.lo splay-tree.lo \
libgomp-plugin.lo oacc-parallel.lo oacc-host.lo oacc-init.lo \
oacc-mem.lo oacc-async.lo oacc-plugin.lo oacc-cuda.lo \
- priority_queue.lo $(am__objects_1)
+ priority_queue.lo oacc-profiling.lo \
+ oacc-profiling-acc_register_library.lo $(am__objects_1)
libgomp_la_OBJECTS = $(am_libgomp_la_OBJECTS)
DEFAULT_INCLUDES = -I.@am__isrc@
depcomp = $(SHELL) $(top_srcdir)/../depcomp
@@ -435,7 +436,8 @@ libgomp_la_SOURCES = alloc.c barrier.c critical.c env.c error.c iter.c \
bar.c ptrlock.c time.c fortran.c affinity.c target.c \
splay-tree.c libgomp-plugin.c oacc-parallel.c oacc-host.c \
oacc-init.c oacc-mem.c oacc-async.c oacc-plugin.c oacc-cuda.c \
- priority_queue.c $(am__append_3)
+ priority_queue.c oacc-profiling.c \
+ oacc-profiling-acc_register_library.c $(am__append_3)
# Nvidia PTX OpenACC plugin.
@PLUGIN_NVPTX_TRUE@libgomp_plugin_nvptx_version_info = -version-info $(libtool_VERSION)
@@ -457,7 +459,7 @@ libgomp_la_SOURCES = alloc.c barrier.c critical.c env.c error.c iter.c \
@PLUGIN_HSA_TRUE@libgomp_plugin_hsa_la_LIBADD = libgomp.la $(PLUGIN_HSA_LIBS)
@PLUGIN_HSA_TRUE@libgomp_plugin_hsa_la_LIBTOOLFLAGS = --tag=disable-static
nodist_noinst_HEADERS = libgomp_f.h
-nodist_libsubinclude_HEADERS = omp.h openacc.h
+nodist_libsubinclude_HEADERS = acc_prof.h omp.h openacc.h
@USE_FORTRAN_TRUE@nodist_finclude_HEADERS = omp_lib.h omp_lib.f90 omp_lib.mod omp_lib_kinds.mod \
@USE_FORTRAN_TRUE@ openacc_lib.h openacc.f90 openacc.mod openacc_kinds.mod
@@ -620,6 +622,8 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-mem.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-parallel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-plugin.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-profiling-acc_register_library.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-profiling.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ordered.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/parallel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/priority_queue.Plo@am__quote@
diff --git libgomp/acc_prof.h libgomp/acc_prof.h
new file mode 100644
index 0000000..9247790
--- /dev/null
+++ libgomp/acc_prof.h
@@ -0,0 +1,237 @@
+/* OpenACC Runtime Library: Profiling Interface
+
+ Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+#ifndef _ACC_PROF_H
+#define _ACC_PROF_H 1
+
+/* The OpenACC standard doesn't say so explicitly, but as its Profiling
+ Interface makes use of, for example, <openacc.h>'s acc_device_t, we
+ supposedly are to #include that file here. */
+#include <openacc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.1. Events. */
+
+typedef enum acc_event_t
+{
+ acc_ev_none = 0,
+ acc_ev_device_init_start,
+ acc_ev_device_init_end,
+ acc_ev_device_shutdown_start,
+ acc_ev_device_shutdown_end,
+ acc_ev_runtime_shutdown,
+ acc_ev_create,
+ acc_ev_delete,
+ acc_ev_alloc,
+ acc_ev_free,
+ acc_ev_enter_data_start,
+ acc_ev_enter_data_end,
+ acc_ev_exit_data_start,
+ acc_ev_exit_data_end,
+ acc_ev_update_start,
+ acc_ev_update_end,
+ acc_ev_compute_construct_start,
+ acc_ev_compute_construct_end,
+ acc_ev_enqueue_launch_start,
+ acc_ev_enqueue_launch_end,
+ acc_ev_enqueue_upload_start,
+ acc_ev_enqueue_upload_end,
+ acc_ev_enqueue_download_start,
+ acc_ev_enqueue_download_end,
+ acc_ev_wait_start,
+ acc_ev_wait_end,
+ acc_ev_last
+} acc_event_t;
+
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.2. Callbacks Signature. */
+
+//TODO
+/* 'In all cases, a datatype of "size_t" means a 32-bit integer for a 32-bit
+ binary and a 64-bit integer for a 64-bit binary, and a datatype "int" means
+ a 32-bit integer for both 32-bit and 64-bit binaries'. */
+typedef long int _acc_prof_size_t;
+typedef int _acc_prof_int_t;
+
+/* Internal helpers: a struct's "valid_bytes" may be less than its "sizeof". */
+#define _ACC_PROF_VALID_BYTES_STRUCT(_struct, _lastfield, _valid_bytes_lastfield) \
+ offsetof (_struct, _lastfield) + (_valid_bytes_lastfield)
+#if 0 /* Untested. */
+#define _ACC_PROF_VALID_BYTES_TYPE_N(_type, _n, _valid_bytes_type) \
+ ((_n - 1) * sizeof (_type) + (_valid_bytes_type))
+#endif
+#define _ACC_PROF_VALID_BYTES_BASICTYPE(_basictype) \
+ (sizeof (_basictype))
+
+typedef struct acc_prof_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ _acc_prof_int_t version;
+ acc_device_t device_type;
+ _acc_prof_int_t device_number;
+ _acc_prof_int_t thread_id;
+ _acc_prof_size_t async;
+ _acc_prof_size_t async_queue;
+ char *src_file;
+ char *func_name;
+ _acc_prof_int_t line_no, end_line_no;
+ _acc_prof_int_t func_line_no, func_end_line_no;
+#define _ACC_PROF_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_prof_info, func_end_line_no, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_int_t))
+} acc_prof_info;
+
+/* We implement the OpenACC 2.5 Profiling Interface. */
+#define _ACC_PROF_INFO_VERSION 201510
+
+typedef enum acc_construct_t
+{
+ acc_construct_parallel = 0,
+ acc_construct_kernels,
+ acc_construct_loop,
+ acc_construct_data,
+ acc_construct_enter_data,
+ acc_construct_exit_data,
+ acc_construct_host_data,
+ acc_construct_atomic,
+ acc_construct_declare,
+ acc_construct_init,
+ acc_construct_shutdown,
+ acc_construct_set,
+ acc_construct_update,
+ acc_construct_routine,
+ acc_construct_wait,
+ acc_construct_runtime_api
+} acc_construct_t;
+
+typedef struct acc_data_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ char *var_name;
+ _acc_prof_size_t bytes;
+ void *host_ptr;
+ void *device_ptr;
+#define _ACC_DATA_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_data_event_info, device_ptr, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_data_event_info;
+
+typedef struct acc_launch_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ char *kernel_name;
+ _acc_prof_size_t num_gangs, num_workers, vector_length;
+#define _ACC_LAUNCH_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_launch_event_info, vector_length, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_size_t))
+} acc_launch_event_info;
+
+typedef struct acc_other_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+#define _ACC_OTHER_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_other_event_info, tool_info, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_other_event_info;
+
+typedef union acc_event_info
+{
+ acc_event_t event_type;
+ acc_data_event_info data_event;
+ acc_launch_event_info launch_event;
+ acc_other_event_info other_event;
+} acc_event_info;
+
+//TODO: should these relate to acc_device_t values?
+typedef enum acc_device_api
+{
+ acc_device_api_none = 0,
+ acc_device_api_cuda,
+ acc_device_api_opencl,
+ acc_device_api_coi,
+ acc_device_api_other
+} acc_device_api;
+
+typedef struct acc_api_info
+{
+ acc_device_api device_api;
+ _acc_prof_int_t valid_bytes;
+ acc_device_t device_type;
+ _acc_prof_int_t vendor;
+ void *device_handle;
+ void *context_handle;
+ void *async_handle;
+#define _ACC_API_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_api_info, async_handle, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_api_info;
+
+typedef void (*acc_prof_callback) (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.3. Loading the Library. */
+
+typedef enum acc_register_t
+{
+ acc_reg = 0,
+ acc_toggle = 1,
+ acc_toggle_per_thread = 2
+} acc_register_t;
+
+typedef void (*acc_prof_reg) (acc_event_t, acc_prof_callback, acc_register_t);
+extern void acc_prof_register (acc_event_t, acc_prof_callback, acc_register_t) __GOACC_NOTHROW;
+extern void acc_prof_unregister (acc_event_t, acc_prof_callback, acc_register_t) __GOACC_NOTHROW;
+typedef void (*acc_query_fn) ();
+typedef acc_query_fn (*acc_prof_lookup_func) (const char *);
+extern acc_query_fn acc_prof_lookup (const char *) __GOACC_NOTHROW;
+/* Don't tag "acc_register_library" as "__GOACC_NOTHROW": this function can be
+ overridden by the application, and must be expected to do "everything". */
+extern void acc_register_library (acc_prof_reg, acc_prof_reg, acc_prof_lookup_func);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ACC_PROF_H */
diff --git libgomp/config/nvptx/oacc-profiling-acc_register_library.c libgomp/config/nvptx/oacc-profiling-acc_register_library.c
new file mode 100644
index 0000000..e69de29
diff --git libgomp/config/nvptx/oacc-profiling.c libgomp/config/nvptx/oacc-profiling.c
new file mode 100644
index 0000000..e69de29
diff --git libgomp/env.c libgomp/env.c
index ac05c3b..75f8272 100644
--- libgomp/env.c
+++ libgomp/env.c
@@ -1301,8 +1301,9 @@ initialize_env (void)
parse_acc_device_type ();
goacc_runtime_initialize ();
-}
+ goacc_profiling_initialize ();
+}
\f
/* The public OpenMP API routines that access these variables. */
diff --git libgomp/libgomp-plugin.c libgomp/libgomp-plugin.c
index 9bd4047..f834306 100644
--- libgomp/libgomp-plugin.c
+++ libgomp/libgomp-plugin.c
@@ -29,6 +29,7 @@
#include <stdlib.h>
#include "libgomp.h"
+#include "oacc-int.h"
#include "libgomp-plugin.h"
void *
@@ -78,3 +79,11 @@ GOMP_PLUGIN_fatal (const char *msg, ...)
gomp_vfatal (msg, ap);
va_end (ap);
}
+
+void
+GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *prof_info,
+ acc_event_info *event_info,
+ acc_api_info *api_info)
+{
+ goacc_profiling_dispatch (prof_info, event_info, api_info);
+}
diff --git libgomp/libgomp-plugin.h libgomp/libgomp-plugin.h
index ff81350..37d9d23 100644
--- libgomp/libgomp-plugin.h
+++ libgomp/libgomp-plugin.h
@@ -33,6 +33,8 @@
#include <stddef.h>
#include <stdint.h>
+#include "acc_prof.h"
+
#ifdef __cplusplus
extern "C" {
#endif
@@ -74,6 +76,10 @@ extern void GOMP_PLUGIN_error (const char *, ...)
extern void GOMP_PLUGIN_fatal (const char *, ...)
__attribute__ ((noreturn, format (printf, 1, 2)));
+extern void GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *,
+ acc_event_info *,
+ acc_api_info *);
+
/* Prototypes for functions implemented by libgomp plugins. */
extern const char *GOMP_OFFLOAD_get_name (void);
extern unsigned int GOMP_OFFLOAD_get_caps (void);
diff --git libgomp/libgomp.map libgomp/libgomp.map
index 2c9a13d..b76a5dd 100644
--- libgomp/libgomp.map
+++ libgomp/libgomp.map
@@ -400,6 +400,10 @@ OACC_2.5 {
acc_get_default_async_h_;
acc_memcpy_from_device_async;
acc_memcpy_to_device_async;
+ acc_prof_lookup;
+ acc_prof_register;
+ acc_prof_unregister;
+ acc_register_library;
acc_set_default_async;
acc_set_default_async_h_;
acc_update_device_async;
@@ -456,3 +460,10 @@ GOMP_PLUGIN_1.2 {
global:
GOMP_PLUGIN_acc_thread_default_async;
} GOMP_PLUGIN_1.1;
+
+# TODO
+GOMP_PLUGIN_1.3 {
+ global:
+ GOMP_PLUGIN_goacc_profiling_dispatch;
+ GOMP_PLUGIN_goacc_thread;
+} GOMP_PLUGIN_1.2;
diff --git libgomp/libgomp.texi libgomp/libgomp.texi
index 7cb677c..93365cd 100644
--- libgomp/libgomp.texi
+++ libgomp/libgomp.texi
@@ -111,6 +111,7 @@ changed to GNU Offloading and Multi Processing Runtime Library.
asynchronous operations.
* OpenACC Library Interoperability:: OpenACC library interoperability with the
NVIDIA CUBLAS library.
+* OpenACC Profiling Interface::
* The libgomp ABI:: Notes on the external ABI presented by libgomp.
* Reporting Bugs:: How to report bugs in the GNU Offloading and
Multi Processing Runtime Library.
@@ -3085,6 +3086,251 @@ Application Programming Interface”, Version 2.0.}
@c ---------------------------------------------------------------------
+@c OpenACC Profiling Interface
+@c ---------------------------------------------------------------------
+
+@node OpenACC Profiling Interface
+@chapter OpenACC Profiling Interface
+
+@section Implementation Status and Implementation-Defined Behavior
+
+We're not yet implementing the whole Profiling Interface as defined by
+the OpenACC 2.5 specification. Also, the specification doesn't
+clearly define some aspects of its Profiling Interface, so we're
+clarifying these as @emph{implementation-defined behavior} here. We
+already have reported to the OpenACC Technical Committee some issues,
+and will report more, later on.
+
+This implementation of the OpenACC Profiling Interface is tuned to
+keep the performance impact as low as possible when it's not in use.
+This is relevant, as the Profiling Interface affects all the
+@emph{hot} code paths (in the target code, not in the offloaded code).
+Users of the OpenACC Profiling Interface can be expected to understand
+that performance will always be impacted to some degree: for example,
+because of the @emph{runtime} (libgomp) calling into a third-party
+@emph{library} for every event that has been registered.
+
+This implementation of the OpenACC Profiling Interface has not yet
+been validated for use in multi-threaded code. This is a more general
+issue; see CSTS-110 @cite{Make sure all OpenACC entry points in
+libgomp are thread-safe}.
+
+The @code{acc_prof_lookup} interface is not implemented, and
+@code{acc_register_library} will receive @code{NULL} for its
+@code{lookup} parameter.
+
+Remarks about data provided to callbacks:
+
+@table @asis
+
+@item @code{acc_prof_info.event_type}
+It is not clear if for @emph{nested} event callbacks (for example,
+@code{acc_ev_enqueue_launch_start} as part of a parent compute
+construct), this should be set for the nested event
+(@code{acc_ev_enqueue_launch_start}), or if the value of the parent
+construct should remain (@code{acc_ev_compute_construct_start}). In
+this implementation, the value will generally correspond to the
+innermost nested event type.
+
+@item @code{acc_prof_info.device_type}
+@itemize
+
+@item
+For @code{acc_ev_compute_construct_start}, and in presence of an
+@code{if} clause with @emph{false} argument, this will still refer to
+the offloading device type; unsure whether that's the expected
+behavior.
+
+@item
+Complementary to the item before, for
+@code{acc_ev_compute_construct_end}, this is set to
+@code{acc_device_host} in presence of an @code{if} clause with
+@emph{false} argument, unsure whether that's the expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.thread_id}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.async}
+@itemize
+
+@item
+Not yet implemented correctly for
+@code{acc_ev_compute_construct_start}.
+
+@item
+In a compute construct, for host-fallback
+execution/@code{acc_device_host} it will always be
+@code{acc_async_sync}; unsure if that is the expected behavior.
+
+@item
+For @code{acc_ev_device_init_start} and @code{acc_ev_device_init_end},
+it will always be @code{acc_async_sync}; unsure if that is the
+expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.async_queue}
+There is no @cite{limited number of asynchronous queues} in libgomp.
+We define this to always have the same value as
+@code{acc_prof_info.async}.
+
+@item @code{acc_prof_info.file}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_prof_info.func_name}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_prof_info.line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_event_info.event_type}, @code{acc_event_info.*.event_type}
+Relating to @code{acc_prof_info.event_type} discussed above, in this
+implementation, this will always be the same value as
+@code{acc_prof_info.event_type}.
+
+@item @code{acc_event_info.*.parent_construct}
+@itemize
+
+@item
+Will be @code{acc_construct_parallel} for OpenACC kernels constructs;
+should be @code{acc_construct_kernels}.
+
+@item
+For implicit @code{acc_ev_device_init_start},
+@code{acc_ev_device_init_end}, and explicit as well as implicit
+@code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start}, and
+@code{acc_ev_enqueue_download_end}, will be
+@code{acc_construct_parallel}; should reflect the real parent
+construct.
+
+@end itemize
+
+@item @code{acc_event_info.*.implicit}
+For @code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start}, and
+@code{acc_ev_enqueue_download_end}, this currently will be @code{1}
+also for explicit usage.
+
+@item @code{acc_event_info.data_event.var_name}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_event_info.data_event.host_ptr}
+For @code{acc_ev_alloc}, and @code{acc_ev_free}, this is always
+@code{NULL}.
+
+@item @code{typedef union acc_api_info}
+@dots{} as printed in @cite{5.2.3. Third Argument: API-Specific
+Information}, should obviously be @code{typedef @emph{struct}
+acc_api_info}.
+
+@item @code{acc_api_info.device_api}
+Possibly not yet implemented correctly for
+@code{acc_ev_compute_construct_start},
+@code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}:
+will always be @code{acc_device_api_none} for these event types.
+For @code{acc_ev_enter_data_start}, it will be
+@code{acc_device_api_none} in some cases.
+
+@item @code{acc_api_info.device_type}
+Always the same as @code{acc_prof_info.device_type}.
+
+@item @code{acc_api_info.vendor}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_api_info.device_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.context_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.async_handle}
+Always @code{NULL}; not yet implemented.
+
+@end table
+
+Remarks about certain event types:
+
+@table @asis
+
+@item @code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}
+@itemize
+
+@item
+@c See DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT in
+@c libgomp.oacc-c-c++-common/acc_prof-parallel-1.c.
+Whan a compute construct triggers implicit
+@code{acc_ev_device_init_start} and @code{acc_ev_device_init_end}
+events, they currently aren't @emph{nested within} the corresponding
+@code{acc_ev_compute_construct_start} and
+@code{acc_ev_compute_construct_end}, but they're currently observed
+@emph{before} @code{acc_ev_compute_construct_start}. It is not clear
+what to do: the standard asks us provide a lot of details to the
+@code{acc_ev_compute_construct_start} callback, without (implicitly)
+initializing a device before?
+
+@item
+Callbacks for these event types will not be invoked for calls to the
+@code{acc_set_device_type} and @code{acc_set_device_num} functions;
+it's not clear if they should be.
+
+@end itemize
+
+@end table
+
+Callbacks for the following event types will be invoked, but dispatch
+and information provided therein has not yet been thoroughly reviewed:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@item @code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end}
+@item @code{acc_ev_enqueue_download_start}, @code{acc_ev_enqueue_download_end}
+@end itemize
+
+During device initialization, and finalization, respectively,
+callbacks for the following event types will not yet be invoked:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@end itemize
+
+Callbacks for the following event types will currently only be invoked
+for (implicit) events within compute constructs:
+
+@itemize
+@item @code{acc_ev_enter_data_start}, @code{acc_ev_enter_data_end}
+@item @code{acc_ev_exit_data_start}, @code{acc_ev_exit_data_end}
+@end itemize
+
+Callbacks for the following event types have not yet been implemented,
+so currently won't be invoked:
+
+@itemize
+@item @code{acc_ev_device_shutdown_start}, @code{acc_ev_device_shutdown_end}
+@item @code{acc_ev_runtime_shutdown}
+@item @code{acc_ev_create}, @code{acc_ev_delete}
+@item @code{acc_ev_update_start}, @code{acc_ev_update_end}
+@item @code{acc_ev_wait_start}, @code{acc_ev_wait_end}
+@end itemize
+
+
+
+@c ---------------------------------------------------------------------
@c The libgomp ABI
@c ---------------------------------------------------------------------
diff --git libgomp/oacc-init.c libgomp/oacc-init.c
index 05bb663..415c0fa 100644
--- libgomp/oacc-init.c
+++ libgomp/oacc-init.c
@@ -218,8 +218,55 @@ acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)
held before calling this function. */
static struct gomp_device_descr *
-acc_init_1 (acc_device_t d)
+acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
{
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_device_init_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = d;
+ prof_info.device_number = goacc_device_num;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = acc_async_sync; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info device_init_event_info;
+ if (profiling_dispatch_p)
+ {
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ device_init_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ device_init_event_info.other_event.parent_construct = parent_construct;
+ device_init_event_info.other_event.implicit = implicit;
+ device_init_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ api_info.device_api = acc_device_api_none; //TODO
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info, &api_info);
+
struct gomp_device_descr *base_dev, *acc_dev;
int ndevs;
@@ -242,6 +289,14 @@ acc_init_1 (acc_device_t d)
gomp_init_device (acc_dev);
gomp_mutex_unlock (&acc_dev->lock);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_device_init_end;
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info,
+ &api_info);
+ }
+
return base_dev;
}
@@ -434,7 +489,11 @@ goacc_attach_host_thread_to_device (int ord)
thr->dev = acc_dev = &base_dev[ord];
thr->saved_bound_dev = NULL;
thr->mapped_data = NULL;
-
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ /* Initially, all callbacks for all events are enabled. */
+ thr->prof_callbacks_enabled = true;
+
thr->target_tls
= acc_dev->openacc.create_thread_data_func (ord);
@@ -452,7 +511,7 @@ acc_init (acc_device_t d)
gomp_mutex_lock (&acc_device_lock);
if (!cached_base_dev)
gomp_init_targets_once ();
- cached_base_dev = acc_init_1 (d);
+ cached_base_dev = acc_init_1 (d, acc_construct_runtime_api, 0);
gomp_mutex_unlock (&acc_device_lock);
goacc_attach_host_thread_to_device (-1);
@@ -708,7 +767,8 @@ goacc_lazy_initialize (void)
if (!cached_base_dev)
{
gomp_init_targets_once ();
- cached_base_dev = acc_init_1 (acc_device_default);
+ cached_base_dev = acc_init_1 (acc_device_default,
+ /* TODO */ acc_construct_parallel, 1);
}
gomp_mutex_unlock (&acc_device_lock);
diff --git libgomp/oacc-int.h libgomp/oacc-int.h
index 1f7adb4..8a62029 100644
--- libgomp/oacc-int.h
+++ libgomp/oacc-int.h
@@ -40,6 +40,7 @@
#include "openacc.h"
#include "config.h"
+#include "acc_prof.h"
#include <stddef.h>
#include <stdbool.h>
#include <stdarg.h>
@@ -68,6 +69,12 @@ struct goacc_thread
strictly push/pop semantics according to lexical scope. */
struct target_mem_desc *mapped_data;
+ /* Data of the OpenACC Profiling Interface. */
+ acc_prof_info *prof_info;
+ acc_api_info *api_info;
+ /* Per-thread toggle of OpenACC Profiling Interface callbacks. */
+ bool prof_callbacks_enabled;
+
/* These structures form a list: this is the next thread in that list. */
struct goacc_thread *next;
@@ -102,6 +109,11 @@ void goacc_restore_bind (void);
void goacc_lazy_initialize (void);
void goacc_host_init (void);
+void goacc_profiling_initialize (void);
+bool goacc_profiling_dispatch_p (void);
+void goacc_profiling_dispatch (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+
#ifdef HAVE_ATTRIBUTE_VISIBILITY
# pragma GCC visibility pop
#endif
diff --git libgomp/oacc-parallel.c libgomp/oacc-parallel.c
index deab4b3..36e2431 100644
--- libgomp/oacc-parallel.c
+++ libgomp/oacc-parallel.c
@@ -142,21 +142,78 @@ GOACC_parallel_keyed (int device, void (*fn) (void *),
thr = goacc_thread ();
acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_compute_construct_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info compute_construct_event_info;
+ if (profiling_dispatch_p)
+ {
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ compute_construct_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ compute_construct_event_info.other_event.parent_construct
+ = acc_construct_parallel; //TODO: kernels...
+ compute_construct_event_info.other_event.implicit = 0;
+ compute_construct_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds);
/* Host fallback if "if" clause is false or if the current device is set to
the host. */
if (host_fallback)
{
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
goacc_save_and_set_bind (acc_device_host);
fn (hostaddrs);
goacc_restore_bind ();
- return;
+ goto out;
}
else if (acc_device_type (acc_dev->type) == acc_device_host)
{
fn (hostaddrs);
- return;
+ goto out;
}
/* Default: let the runtime choose. */
@@ -190,6 +247,14 @@ GOACC_parallel_keyed (int device, void (*fn) (void *),
if (async == GOMP_LAUNCH_OP_MAX)
async = va_arg (ap, unsigned);
+
+ if (profiling_dispatch_p)
+ {
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
break;
}
@@ -227,8 +292,31 @@ GOACC_parallel_keyed (int device, void (*fn) (void *),
else
tgt_fn = (void (*)) fn;
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_start;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = compute_construct_event_info.other_event.parent_construct;
+ enter_exit_data_event_info.other_event.implicit = 1;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
tgt = gomp_map_vars (acc_dev, mapnum, hostaddrs, NULL, sizes, kinds, true,
GOMP_MAP_VARS_OPENACC);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
devaddrs = gomp_alloca (sizeof (void *) * mapnum);
for (i = 0; i < mapnum; i++)
@@ -246,11 +334,43 @@ GOACC_parallel_keyed (int device, void (*fn) (void *),
/* If running synchronously, unmap immediately. */
if (async < acc_async_noval)
- gomp_unmap_vars (tgt, true);
+ {
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_start;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
+ gomp_unmap_vars (tgt, true);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
+ }
else
tgt->device_descr->openacc.register_async_cleanup_func (tgt, async);
acc_dev->openacc.async_set_async_func (acc_async_sync);
+
+ out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_compute_construct_end;
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
/* Legacy entry point, only provide host execution. */
diff --git libgomp/oacc-plugin.c libgomp/oacc-plugin.c
index 3f82c07..9707b48 100644
--- libgomp/oacc-plugin.c
+++ libgomp/oacc-plugin.c
@@ -50,6 +50,19 @@ GOMP_PLUGIN_acc_thread (void)
return thr ? thr->target_tls : NULL;
}
+/* Return the TLS data for the current thread. */
+/* TODO. Should we be able to directly call (the static inline function)
+ goacc_thread from within plugin code? I didn't manage to get the
+ "goacc_tls_data" symbol configured correctly: "[...]/ld:
+ .libs/libgomp-plugin-nvptx.so.1.0.0: hidden symbol `goacc_tls_data' isn't
+ defined". */
+
+struct goacc_thread *
+GOMP_PLUGIN_goacc_thread (void)
+{
+ return goacc_thread ();
+}
+
/* Return the default async number from the TLS data for the current thread. */
int
diff --git libgomp/oacc-plugin.h libgomp/oacc-plugin.h
index ff46ed8..5a842a2 100644
--- libgomp/oacc-plugin.h
+++ libgomp/oacc-plugin.h
@@ -27,8 +27,11 @@
#ifndef OACC_PLUGIN_H
#define OACC_PLUGIN_H 1
+#include "oacc-int.h"
+
extern void GOMP_PLUGIN_async_unmap_vars (void *, int);
extern void *GOMP_PLUGIN_acc_thread (void);
+extern struct goacc_thread *GOMP_PLUGIN_goacc_thread (void);
extern int GOMP_PLUGIN_acc_thread_default_async (void);
#endif
diff --git libgomp/oacc-plugin.h libgomp/oacc-profiling-acc_register_library.c
similarity index 71%
copy from libgomp/oacc-plugin.h
copy to libgomp/oacc-profiling-acc_register_library.c
index ff46ed8..f6b482b 100644
--- libgomp/oacc-plugin.h
+++ libgomp/oacc-profiling-acc_register_library.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2014-2016 Free Software Foundation, Inc.
+/* Copyright (C) 2017 Free Software Foundation, Inc.
Contributed by Mentor Embedded.
@@ -24,11 +24,16 @@
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
-#ifndef OACC_PLUGIN_H
-#define OACC_PLUGIN_H 1
+/* This file provides an stub acc_register_library function. It's in a
+ separate file so that this function can easily be overridden when linking
+ statically. */
-extern void GOMP_PLUGIN_async_unmap_vars (void *, int);
-extern void *GOMP_PLUGIN_acc_thread (void);
-extern int GOMP_PLUGIN_acc_thread_default_async (void);
+#include "libgomp.h"
+#include "acc_prof.h"
-#endif
+void
+acc_register_library (acc_prof_reg reg, acc_prof_reg unreg,
+ acc_prof_lookup_func lookup)
+{
+ gomp_debug (0, "dummy %s\n", __FUNCTION__);
+}
diff --git libgomp/oacc-profiling.c libgomp/oacc-profiling.c
new file mode 100644
index 0000000..a4671f9
--- /dev/null
+++ libgomp/oacc-profiling.c
@@ -0,0 +1,576 @@
+/* Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+/* OpenACC Profiling Interface. */
+
+#include "libgomp.h"
+#include "oacc-int.h"
+#include "acc_prof.h"
+#include <assert.h>
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+#ifdef PLUGIN_SUPPORT
+# include <dlfcn.h>
+#endif
+
+#define STATIC_ASSERT(expr) _Static_assert (expr, "!(" #expr ")")
+
+/* Statically assert that the layout of the common fields in the
+ "acc_event_info" variants matches. */
+/* event_type */
+STATIC_ASSERT (offsetof (acc_event_info, event_type)
+ == offsetof (acc_event_info, data_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, launch_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, other_event.event_type));
+/* valid_bytes */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, launch_event.valid_bytes));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, other_event.valid_bytes));
+/* parent_construct */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, launch_event.parent_construct));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, other_event.parent_construct));
+/* implicit */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, launch_event.implicit));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, other_event.implicit));
+/* tool_info */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, launch_event.tool_info));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, other_event.tool_info));
+
+struct goacc_prof_callback_entry
+{
+ acc_prof_callback cb;
+ int ref;
+ bool enabled;
+ struct goacc_prof_callback_entry *next;
+};
+
+/* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global toggle. */
+static bool goacc_prof_callbacks_enabled[acc_ev_last];
+static struct goacc_prof_callback_entry *goacc_prof_callback_entries[acc_ev_last];
+
+/* This lock is used to protect access to goacc_prof_callbacks_enabled, and
+ goacc_prof_callback_entries. */
+static gomp_mutex_t goacc_prof_lock;
+
+void
+goacc_profiling_initialize (void)
+{
+ gomp_mutex_init (&goacc_prof_lock);
+
+ /* Initially, all callbacks for all events are enabled. */
+ for (int i = 0; i < acc_ev_last; ++i)
+ goacc_prof_callbacks_enabled[i] = true;
+
+ /* We are to invoke an external acc_register_library routine, defaulting to
+ our stub oacc-profiling-acc_register_library.c:acc_register_library
+ implementation. */
+ gomp_debug (0, "%s: calling acc_register_library\n", __FUNCTION__);
+ //TODO.
+ acc_register_library (acc_prof_register, acc_prof_unregister, NULL);
+#ifdef PLUGIN_SUPPORT
+ char *acc_proflibs = getenv ("ACC_PROFLIB");
+ while (acc_proflibs != NULL && acc_proflibs[0] != '\0')
+ {
+ char *acc_proflibs_sep = strchr (acc_proflibs, ';');
+ char *acc_proflib;
+ if (acc_proflibs_sep == acc_proflibs)
+ {
+ /* Stray ";" separator: make sure we don't dlopen the main
+ program. */
+ acc_proflib = NULL;
+ }
+ else
+ {
+ if (acc_proflibs_sep != NULL)
+ {
+ /* Single out the first library. */
+ acc_proflib = gomp_malloc (acc_proflibs_sep - acc_proflibs + 1);
+ memcpy (acc_proflib, acc_proflibs,
+ acc_proflibs_sep - acc_proflibs);
+ acc_proflib[acc_proflibs_sep - acc_proflibs] = '\0';
+ }
+ else
+ {
+ /* No ";" separator, so only one library. */
+ acc_proflib = acc_proflibs;
+ }
+
+ gomp_debug (0, "%s: dlopen(%s)\n", __FUNCTION__, acc_proflib);
+ void *dl_handle = dlopen (acc_proflib, RTLD_LAZY);
+ if (dl_handle != NULL)
+ {
+ typeof (&acc_register_library) a_r_l
+ = dlsym (dl_handle, "acc_register_library");
+ if (a_r_l == NULL)
+ goto dl_fail;
+ /* Avoid duplicate registration, for example if the same shared
+ library is specified in LD_PRELOAD and ACC_PROFLIB -- which
+ TAU 2.26 does when using "tau_exec -openacc". */
+ if (a_r_l != acc_register_library)
+ {
+ gomp_debug (0, " %s: calling %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ //TODO.
+ a_r_l (acc_prof_register, acc_prof_unregister, NULL);
+ }
+ else
+ gomp_debug (0, " %s: skipping duplicate"
+ " %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ }
+ else
+ {
+ dl_fail:
+ gomp_error ("while loading ACC_PROFLIB %s: %s",
+ acc_proflib, dlerror ());
+ if (dl_handle != NULL)
+ {
+ int err = dlclose (dl_handle);
+ dl_handle = NULL;
+ if (err != 0)
+ goto dl_fail;
+ }
+ }
+ }
+
+ if (acc_proflib != acc_proflibs)
+ {
+ free (acc_proflib);
+
+ acc_proflibs = acc_proflibs_sep + 1;
+ }
+ else
+ acc_proflibs = NULL;
+ }
+#endif /* PLUGIN_SUPPORT */
+}
+
+void
+acc_prof_register (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ //TODO
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+ enum
+ {
+ EVENT_KIND_BOGUS,
+ EVENT_KIND_NORMAL,
+ /* As end events invoke callbacks in the reverse order, we register these
+ in the reverse order here. */
+ EVENT_KIND_END,
+ } event_kind = EVENT_KIND_BOGUS;
+ switch (ev)
+ {
+ case acc_ev_none:
+ case acc_ev_device_init_start:
+ case acc_ev_device_shutdown_start:
+ case acc_ev_runtime_shutdown:
+ case acc_ev_create:
+ case acc_ev_delete:
+ case acc_ev_alloc:
+ case acc_ev_free:
+ case acc_ev_enter_data_start:
+ case acc_ev_exit_data_start:
+ case acc_ev_update_start:
+ case acc_ev_compute_construct_start:
+ case acc_ev_enqueue_launch_start:
+ case acc_ev_enqueue_upload_start:
+ case acc_ev_enqueue_download_start:
+ case acc_ev_wait_start:
+ event_kind = EVENT_KIND_NORMAL;
+ break;
+ case acc_ev_device_init_end:
+ case acc_ev_device_shutdown_end:
+ case acc_ev_enter_data_end:
+ case acc_ev_exit_data_end:
+ case acc_ev_update_end:
+ case acc_ev_compute_construct_end:
+ case acc_ev_enqueue_launch_end:
+ case acc_ev_enqueue_upload_end:
+ case acc_ev_enqueue_download_end:
+ case acc_ev_wait_end:
+ event_kind = EVENT_KIND_END;
+ break;
+ case acc_ev_last:
+ break;
+ }
+ if (event_kind == EVENT_KIND_BOGUS)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request for TODOinvalid acc_event_t %d",
+ __FUNCTION__, /* TODO */ (int) ev);
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request with TODOinvalid acc_register_t %d",
+ __FUNCTION__, /* TODO */ (int) reg);
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally enabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global
+ toggle. */
+ goacc_prof_callbacks_enabled[ev] = true;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ /* Silently ignore request. */
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: enabling callbacks\n");
+ goacc_lazy_initialize ();
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = true;
+ return;
+ }
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these?
+ gomp_error ("ignoring %s request for acc_toggle_per_thread with TODO",
+ __FUNCTION__);
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ /* If we already have this callback registered, just increment its ref
+ count. */
+ if (it != NULL)
+ {
+ it->ref++;
+ gomp_debug (0, " already registered;"
+ " incrementing ref count to: %d\n", it->ref);
+ }
+ else
+ {
+ struct goacc_prof_callback_entry *e
+ = gomp_malloc (sizeof (struct goacc_prof_callback_entry));
+ e->cb = cb;
+ e->ref = 1;
+ e->enabled = true;
+ bool prepend = (event_kind == EVENT_KIND_END);
+ /* If we don't have any callback registered yet, also use the
+ "prepend" code path. */
+ if (it_p == NULL)
+ prepend = true;
+ if (prepend)
+ {
+ gomp_debug (0, " prepending\n");
+ e->next = goacc_prof_callback_entries[ev];
+ goacc_prof_callback_entries[ev] = e;
+ }
+ else
+ {
+ gomp_debug (0, " appending\n");
+ e->next = NULL;
+ it_p->next = e;
+ }
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ /* Silently ignore acc_toggle request if not registered. */
+ gomp_debug (0, " not enabling; not registered\n");
+ }
+ else
+ {
+ gomp_debug (0, " enabling\n");
+ it->enabled = true;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+void
+acc_prof_unregister (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ //TODO
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+ if (ev < acc_ev_none
+ || ev >= acc_ev_last)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request for TODOinvalid acc_event_t %d",
+ __FUNCTION__, /* TODO */ (int) ev);
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request with TODOinvalid acc_register_t %d",
+ __FUNCTION__, /* TODO */ (int) reg);
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally disabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global
+ toggle. */
+ goacc_prof_callbacks_enabled[ev] = false;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ /* Silently ignore request. */
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: disabling callbacks\n");
+ goacc_lazy_initialize ();
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = false;
+ return;
+ }
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these?
+ gomp_error ("ignoring %s request for acc_toggle_per_thread with TODO",
+ __FUNCTION__);
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ if (it == NULL)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these?
+ gomp_error ("ignoring %s request for acc_event_t %d: not registered",
+ __FUNCTION__, /* TODO */ (int) ev);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ it->ref--;
+ gomp_debug (0, " decrementing ref count to: %d\n", it->ref);
+ if (it->ref == 0)
+ {
+ if (it_p == NULL)
+ goacc_prof_callback_entries[ev] = it->next;
+ else
+ it_p->next = it->next;
+ free (it);
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ /* Silently ignore acc_toggle request if not registered. */
+ gomp_debug (0, " not disabling; not registered\n");
+ }
+ else
+ {
+ gomp_debug (0, " disabling\n");
+ it->enabled = false;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+/* Prepare to dispatch events? */
+
+bool
+goacc_profiling_dispatch_p (void)
+{
+ //TODO
+ gomp_debug (0, "%s\n", __FUNCTION__);
+
+ struct goacc_thread *thr = goacc_thread ();
+ if (__builtin_expect (thr == NULL, false))
+ {
+ /* If we don't have any per-thread state yet, that means that per-thread
+ callback dispatch has not been explicitly disabled (which only a call
+ to acc_prof_unregister with acc_toggle_per_thread will do, and that
+ would have allocated per-thread state via goacc_lazy_initialize);
+ initially, all callbacks for all events are enabled. */
+ //TODO
+ gomp_debug (0, " %s: don't have any per-thread state yet\n", __FUNCTION__);
+ }
+ else if (__builtin_expect (!thr->prof_callbacks_enabled, true))
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled for this thread\n", __FUNCTION__);
+ return false;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global toggle. */
+ if (__builtin_expect (!goacc_prof_callbacks_enabled[acc_ev_none], true))
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled globally\n", __FUNCTION__);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return false;
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+
+ return true;
+}
+
+/* Dispatch events.
+
+ TODO.
+ This must only be called if goacc_profiling_dispatch_p returned a true
+ result. */
+
+void
+goacc_profiling_dispatch (acc_prof_info *prof_info, acc_event_info *event_info,
+ acc_api_info *apt_info)
+{
+ acc_event_t event_type = event_info->event_type;
+ //TODO
+ gomp_debug (0, "%s: event_type=%d\n", __FUNCTION__, (int) event_type);
+ //TODO
+ assert (event_type > acc_ev_none
+ && event_type < acc_ev_last);
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ if (!goacc_prof_callbacks_enabled[event_type])
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled for this event type\n", __FUNCTION__);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+
+ for (struct goacc_prof_callback_entry *e
+ = goacc_prof_callback_entries[event_type];
+ e != NULL;
+ e = e->next)
+ {
+ if (!e->enabled)
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled for callback %p\n",
+ __FUNCTION__, e->cb);
+ continue;
+ }
+
+ //TODO
+ gomp_debug (0, " %s: calling callback %p\n", __FUNCTION__, e->cb);
+ e->cb (prof_info, event_info, apt_info);
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
diff --git libgomp/plugin/plugin-nvptx.c libgomp/plugin/plugin-nvptx.c
index 51000f3..dbea9da 100644
--- libgomp/plugin/plugin-nvptx.c
+++ libgomp/plugin/plugin-nvptx.c
@@ -36,6 +36,7 @@
#include "libgomp-plugin.h"
#include "oacc-plugin.h"
#include "gomp-constants.h"
+#include "oacc-int.h"
#include <pthread.h>
#include <cuda.h>
@@ -121,7 +122,7 @@ struct nvptx_thread
};
static struct cuda_map *
-cuda_map_create (size_t size)
+cuda_map_create (struct goacc_thread *thr, size_t size)
{
struct cuda_map *map = GOMP_PLUGIN_malloc (sizeof (struct cuda_map));
@@ -134,13 +135,72 @@ cuda_map_create (size_t size)
CUDA_CALL_ERET (NULL, cuMemAlloc, &map->d, size);
assert (map->d);
+ bool profiling_dispatch_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_alloc;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ /* Always implicit for "data mapping arguments for cuLaunchKernel". */
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = size;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = (void *) map->d;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
return map;
}
static void
-cuda_map_destroy (struct cuda_map *map)
+cuda_map_destroy (struct goacc_thread *thr, struct cuda_map *map)
{
CUDA_CALL_ASSERT (cuMemFree, map->d);
+
+ bool profiling_dispatch_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_free;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ /* Always implicit for "data mapping arguments for cuLaunchKernel". */
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = map->size;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = (void *) map->d;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
free (map);
}
@@ -156,30 +216,30 @@ cuda_map_destroy (struct cuda_map *map)
GOMP_OFFLOAD_fini_device, respectively. */
static bool
-map_init (struct ptx_stream *s)
+map_init (struct goacc_thread *thr, struct ptx_stream *s)
{
int size = getpagesize ();
assert (s);
- s->map = cuda_map_create (size);
+ s->map = cuda_map_create (thr, size);
return true;
}
static bool
-map_fini (struct ptx_stream *s)
+map_fini (struct goacc_thread *thr, struct ptx_stream *s)
{
assert (s->map->next == NULL);
assert (!s->map->active);
- cuda_map_destroy (s->map);
+ cuda_map_destroy (thr, s->map);
return true;
}
static void
-map_pop (struct ptx_stream *s)
+map_pop (struct goacc_thread *thr, struct ptx_stream *s)
{
struct cuda_map *next;
@@ -192,12 +252,12 @@ map_pop (struct ptx_stream *s)
}
next = s->map->next;
- cuda_map_destroy (s->map);
+ cuda_map_destroy (thr, s->map);
s->map = next;
}
static CUdeviceptr
-map_push (struct ptx_stream *s, size_t size)
+map_push (struct goacc_thread *thr, struct ptx_stream *s, size_t size)
{
struct cuda_map *map = NULL, *t = NULL;
@@ -209,7 +269,7 @@ map_push (struct ptx_stream *s, size_t size)
cuda_map and push it to the end of the list. */
if (s->map->active)
{
- map = cuda_map_create (size);
+ map = cuda_map_create (thr, size);
for (t = s->map; t->next != NULL; t = t->next)
;
@@ -218,8 +278,8 @@ map_push (struct ptx_stream *s, size_t size)
}
else if (s->map->size < size)
{
- cuda_map_destroy (s->map);
- map = cuda_map_create (size);
+ cuda_map_destroy (thr, s->map);
+ map = cuda_map_create (thr, size);
}
else
map = s->map;
@@ -365,7 +425,7 @@ init_streams_for_device (struct ptx_device *ptx_dev, int concurrency)
null_stream->stream = NULL;
null_stream->host_thread = pthread_self ();
null_stream->multithreaded = true;
- if (!map_init (null_stream))
+ if (!map_init (NULL, null_stream))
return false;
ptx_dev->null_stream = null_stream;
@@ -399,7 +459,7 @@ fini_streams_for_device (struct ptx_device *ptx_dev)
struct ptx_stream *s = ptx_dev->active_streams;
ptx_dev->active_streams = ptx_dev->active_streams->next;
- ret &= map_fini (s);
+ ret &= map_fini (NULL, s);
CUresult r = cuStreamDestroy (s->stream);
if (r != CUDA_SUCCESS)
@@ -410,7 +470,7 @@ fini_streams_for_device (struct ptx_device *ptx_dev)
free (s);
}
- ret &= map_fini (ptx_dev->null_stream);
+ ret &= map_fini (NULL, ptx_dev->null_stream);
free (ptx_dev->null_stream);
return ret;
}
@@ -425,7 +485,8 @@ static struct ptx_stream *
select_stream_for_async (int async, pthread_t thread, bool create,
CUstream existing)
{
- struct nvptx_thread *nvthd = nvptx_thread ();
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ struct nvptx_thread *nvthd = (struct nvptx_thread *) thr->target_tls;
/* Local copy of TLS variable. */
struct ptx_device *ptx_dev = nvthd->ptx_dev;
struct ptx_stream *stream = NULL;
@@ -495,7 +556,7 @@ select_stream_for_async (int async, pthread_t thread, bool create,
s->host_thread = thread;
s->multithreaded = false;
- if (!map_init (s))
+ if (!map_init (thr, s))
{
pthread_mutex_unlock (&ptx_dev->stream_lock);
GOMP_PLUGIN_fatal ("map_init fail");
@@ -840,7 +901,8 @@ event_gc (bool memmap_lockable)
{
struct ptx_event *ptx_event = ptx_events;
struct ptx_event *async_cleanups = NULL;
- struct nvptx_thread *nvthd = nvptx_thread ();
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ struct nvptx_thread *nvthd = (struct nvptx_thread *) thr->target_tls;
pthread_mutex_lock (&ptx_event_lock);
@@ -869,7 +931,7 @@ event_gc (bool memmap_lockable)
break;
case PTX_EVT_KNL:
- map_pop (e->addr);
+ map_pop (thr, e->addr);
break;
case PTX_EVT_ASYNC_CLEANUP:
@@ -960,7 +1022,8 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
void *kargs[1];
void *hp;
CUdeviceptr dp;
- struct nvptx_thread *nvthd = nvptx_thread ();
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ struct nvptx_thread *nvthd = (struct nvptx_thread *) thr->target_tls;
const char *maybe_abort_msg = "(perhaps abort was called)";
int cpu_size = nvptx_thread ()->ptx_dev->max_threads_per_multiprocessor;
int block_size = nvptx_thread ()->ptx_dev->max_threads_per_block;
@@ -1108,7 +1171,7 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
the host and the device. HP is a host pointer to the new chunk, and DP is
the corresponding device pointer. */
pthread_mutex_lock (&ptx_event_lock);
- dp = map_push (dev_str, mapnum * sizeof (void *));
+ dp = map_push (thr, dev_str, mapnum * sizeof (void *));
pthread_mutex_unlock (&ptx_event_lock);
GOMP_PLUGIN_debug (0, " %s: prepare mappings\n", __FUNCTION__);
@@ -1120,8 +1183,45 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
/* Copy the (device) pointers to arguments to the device (dp and hp might in
fact have the same value on a unified-memory system). */
+
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ /* Always implicit for "data mapping arguments for cuLaunchKernel". */
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = mapnum * sizeof (void *);
+ data_event_info.data_event.host_ptr = hp;
+ data_event_info.data_event.device_ptr = (void *) dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
CUDA_CALL_ASSERT (cuMemcpyHtoD, dp, hp,
mapnum * sizeof (void *));
+
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
GOMP_PLUGIN_debug (0, " %s: kernel %s: launch"
" gangs=%u, workers=%u, vectors=%u\n",
__FUNCTION__, targ_fn->launch->fn, dims[GOMP_DIM_GANG],
@@ -1133,11 +1233,47 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
// num_workers ntid.y
// vector length ntid.x
+ acc_event_info enqueue_launch_event_info;
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_start;
+
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ enqueue_launch_event_info.launch_event.valid_bytes
+ = _ACC_LAUNCH_EVENT_INFO_VALID_BYTES;
+ enqueue_launch_event_info.launch_event.parent_construct
+ /* TODO = compute_construct_event_info.other_event.parent_construct */
+ = acc_construct_parallel; //TODO: kernels...
+ enqueue_launch_event_info.launch_event.implicit = 1;
+ enqueue_launch_event_info.launch_event.tool_info = NULL;
+ enqueue_launch_event_info.launch_event.kernel_name
+ = /* TODO */ (char *) /* TODO */ targ_fn->launch->fn;
+ enqueue_launch_event_info.launch_event.num_gangs
+ = dims[GOMP_DIM_GANG];
+ enqueue_launch_event_info.launch_event.num_workers
+ = dims[GOMP_DIM_WORKER];
+ enqueue_launch_event_info.launch_event.vector_length
+ = dims[GOMP_DIM_VECTOR];
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
kargs[0] = &dp;
CUDA_CALL_ASSERT (cuLaunchKernel, function,
dims[GOMP_DIM_GANG], 1, 1,
dims[GOMP_DIM_VECTOR], dims[GOMP_DIM_WORKER], 1,
0, dev_str->stream, kargs, 0);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_end;
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
#ifndef DISABLE_ASYNC
if (async < acc_async_noval)
@@ -1183,7 +1319,7 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
#ifndef DISABLE_ASYNC
if (async < acc_async_noval)
#endif
- map_pop (dev_str);
+ map_pop (thr, dev_str);
}
void * openacc_get_current_cuda_context (void);
@@ -1194,6 +1330,34 @@ nvptx_alloc (size_t s)
CUdeviceptr d;
CUDA_CALL_ERET (NULL, cuMemAlloc, &d, s);
+
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_alloc;
+
+ acc_event_info data_event_info;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ data_event_info.data_event.implicit = 1; //TODO
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = s;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = (void *) d;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
return (void *) d;
}
@@ -1211,6 +1375,34 @@ nvptx_free (void *p)
}
CUDA_CALL (cuMemFree, (CUdeviceptr) p);
+
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_free;
+
+ acc_event_info data_event_info;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ data_event_info.data_event.implicit = 1; //TODO
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = ps;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = p;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
return true;
}
@@ -1220,7 +1412,8 @@ nvptx_host2dev (void *d, const void *h, size_t s)
{
CUdeviceptr pb;
size_t ps;
- struct nvptx_thread *nvthd = nvptx_thread ();
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ struct nvptx_thread *nvthd = (struct nvptx_thread *) thr->target_tls;
if (!s)
return true;
@@ -1253,6 +1446,32 @@ nvptx_host2dev (void *d, const void *h, size_t s)
return false;
}
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ data_event_info.data_event.implicit = 1; //TODO
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = s;
+ data_event_info.data_event.host_ptr = /* TODO */ (void *) h;
+ data_event_info.data_event.device_ptr = d;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
#ifndef DISABLE_ASYNC
if (nvthd->current_stream != nvthd->ptx_dev->null_stream)
{
@@ -1268,6 +1487,14 @@ nvptx_host2dev (void *d, const void *h, size_t s)
#endif
CUDA_CALL (cuMemcpyHtoD, (CUdeviceptr) d, h, s);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
return true;
}
@@ -1276,7 +1503,8 @@ nvptx_dev2host (void *h, const void *d, size_t s)
{
CUdeviceptr pb;
size_t ps;
- struct nvptx_thread *nvthd = nvptx_thread ();
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ struct nvptx_thread *nvthd = (struct nvptx_thread *) thr->target_tls;
if (!s)
return true;
@@ -1309,6 +1537,32 @@ nvptx_dev2host (void *h, const void *d, size_t s)
return false;
}
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_download_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ data_event_info.data_event.implicit = 1; //TODO
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = s;
+ data_event_info.data_event.host_ptr = h;
+ data_event_info.data_event.device_ptr = /* TODO */ (void *) d;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
#ifndef DISABLE_ASYNC
if (nvthd->current_stream != nvthd->ptx_dev->null_stream)
{
@@ -1324,6 +1578,14 @@ nvptx_dev2host (void *h, const void *d, size_t s)
#endif
CUDA_CALL (cuMemcpyDtoH, h, (CUdeviceptr) d, s);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_download_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
return true;
}
@@ -1555,7 +1817,8 @@ nvptx_set_cuda_stream (int async, void *stream)
{
struct ptx_stream *oldstream;
pthread_t self = pthread_self ();
- struct nvptx_thread *nvthd = nvptx_thread ();
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ struct nvptx_thread *nvthd = (struct nvptx_thread *) thr->target_tls;
if (async < 0)
GOMP_PLUGIN_fatal ("bad async %d", async);
@@ -1586,7 +1849,7 @@ nvptx_set_cuda_stream (int async, void *stream)
CUDA_CALL_ASSERT (cuStreamDestroy, oldstream->stream);
- if (!map_fini (oldstream))
+ if (!map_fini (thr, oldstream))
GOMP_PLUGIN_fatal ("error when freeing host memory");
free (oldstream);
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
new file mode 100644
index 0000000..4c1f2bb
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
@@ -0,0 +1,344 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+void cb_compute_construct_start_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 10
+ || state == 30
+ || state == 41
+ || state == 51
+ || state == 91
+ || state == 101
+ || state == 151);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_start_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 11
+ || state == 40
+ || state == 50
+ || state == 90
+ || state == 100
+ || state == 150);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 14
+ || state == 21
+ || state == 32
+ || state == 42
+ || state == 80
+ || state == 103
+ || state == 152);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 13
+ || state == 43
+ || state == 102
+ || state == 154);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_3 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 12
+ || state == 20
+ || state == 31
+ || state == 44
+ || state == 81
+ || state == 104
+ || state == 153);
+ STATE_OP (state, ++);
+}
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 2);
+ }
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 12);
+ }
+ assert (state == 15);
+
+ STATE_OP (state, = 20);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 20);
+ }
+ assert (state == 20);
+
+ STATE_OP (state, = 30);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 31);
+ }
+ assert (state == 33);
+
+ STATE_OP (state, = 40);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 42);
+ }
+ assert (state == 45);
+
+ STATE_OP (state, = 50);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 52);
+ }
+ assert (state == 52);
+
+ STATE_OP (state, = 60);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 60);
+ }
+ assert (state == 60);
+
+ STATE_OP (state, = 70);
+ unreg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 70);
+ }
+ assert (state == 70);
+
+ STATE_OP (state, = 80);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 80);
+ }
+ assert (state == 82);
+
+ STATE_OP (state, = 90);
+ reg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 92);
+ }
+ assert (state == 92);
+
+ STATE_OP (state, = 100);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 102);
+ }
+ assert (state == 105);
+
+ STATE_OP (state, = 110);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 110);
+ }
+ assert (state == 110);
+
+ STATE_OP (state, = 120);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 120);
+ }
+ assert (state == 120);
+
+ STATE_OP (state, = 130);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 130);
+ }
+ assert (state == 130);
+
+ STATE_OP (state, = 140);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 140);
+ }
+ assert (state == 140);
+
+ STATE_OP (state, = 150);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 152);
+ }
+ assert (state == 155);
+
+ return 0;
+}
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
new file mode 100644
index 0000000..436f436
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
@@ -0,0 +1,306 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 1)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 2)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 10
+ || state == 110);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 11
+ || state == 111);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ assert (state == 0);
+
+ acc_init (acc_device_host);
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = 12;
+
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 11);
+ }
+ assert (state == 12);
+
+ STATE_OP (state, = 90);
+ acc_shutdown (acc_device_host);
+ assert (state == 90);
+
+
+ STATE_OP (state, = 100);
+ acc_init (acc_device_default);
+ assert (state == 102);
+
+ STATE_OP (state, = 110);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = 12;
+
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 111);
+ }
+ assert (state == 112);
+
+ STATE_OP (state, = 190);
+ acc_shutdown (acc_device_default);
+ assert (state == 190);
+
+ return 0;
+}
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
new file mode 100644
index 0000000..de26323
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
@@ -0,0 +1,703 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+/* See the "DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT" reference in
+ libgomp.texi. */
+#define DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT 0
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+#else
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+#else
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+#endif
+}
+
+void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 2
+ || state == 102);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_device_init_start);
+#else
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (event_info->other_event.tool_info == tool_info->nested);
+#else
+ assert (event_info->other_event.tool_info == tool_info);
+#endif
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+#else
+ free (tool_info);
+ tool_info = NULL;
+#endif
+}
+
+void cb_enter_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 3
+ || state == 103);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enter_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ if (acc_device_type == acc_device_host
+ || state < 100) //TODO
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_enter_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 4
+ || state == 104);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_enter_data_start);
+
+ assert (prof_info->event_type == acc_ev_enter_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+void cb_exit_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 7);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_exit_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_exit_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 8);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_exit_data_start);
+
+ assert (prof_info->event_type == acc_ev_exit_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 0
+ || state == 100);
+ if (state == 100)
+ {
+ /* Compensate for the missing acc_ev_device_init_start and
+ acc_ev_device_init_end. */
+ state += 2;
+ }
+#else
+ if (state == 100)
+ {
+ /* Compensate for the missing acc_ev_device_init_start and
+ acc_ev_device_init_end. */
+ state += 2;
+ }
+ assert (state == 2
+ || state == 102);
+#endif
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing acc_ev_enter_data_start. */
+ state += 1;
+ }
+}
+
+void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing acc_ev_enter_data_end. */
+ state += 1;
+ /* Compensate for the missing acc_ev_enqueue_launch_start and
+ acc_ev_enqueue_launch_end. */
+ state += 2;
+ /* Compensate for the missing acc_ev_exit_data_start and
+ acc_ev_exit_data_end. */
+ state += 2;
+ }
+ else if (acc_async != acc_async_sync)
+ {
+ /* Compensate for the missing acc_ev_exit_data_start and
+ acc_ev_exit_data_end. */
+ state += 2;
+ }
+ assert (state == 9
+ || state == 109);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 5
+ || state == 105);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == NULL);
+ assert (event_info->launch_event.kernel_name != NULL);
+ {
+ char *s = strstr (event_info->launch_event.kernel_name, "main");
+ assert (s != NULL);
+ s = strstr (s, "omp_fn");
+ assert (s != NULL);
+ }
+ assert (event_info->launch_event.num_gangs >= 1);
+ assert (event_info->launch_event.num_workers >= 1);
+ assert (event_info->launch_event.vector_length >= 1);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.launch_event.event_type = event_info->launch_event.event_type;
+ tool_info->nested->event_info.launch_event.kernel_name = strdup (event_info->launch_event.kernel_name);
+ tool_info->nested->event_info.launch_event.num_gangs = event_info->launch_event.num_gangs;
+ tool_info->nested->event_info.launch_event.num_workers = event_info->launch_event.num_workers;
+ tool_info->nested->event_info.launch_event.vector_length = event_info->launch_event.vector_length;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_enqueue_launch_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 6
+ || state == 106);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.launch_event.event_type == acc_ev_enqueue_launch_start);
+ assert (tool_info->nested->event_info.launch_event.kernel_name != NULL);
+ assert (tool_info->nested->event_info.launch_event.num_gangs >= 1);
+ assert (tool_info->nested->event_info.launch_event.num_workers >= 1);
+ assert (tool_info->nested->event_info.launch_event.vector_length >= 1);
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == tool_info->nested);
+ assert (event_info->launch_event.kernel_name != NULL);
+ assert (strcmp (event_info->launch_event.kernel_name, tool_info->nested->event_info.launch_event.kernel_name) == 0);
+ assert (event_info->launch_event.num_gangs == tool_info->nested->event_info.launch_event.num_gangs);
+ assert (event_info->launch_event.num_workers == tool_info->nested->event_info.launch_event.num_workers);
+ assert (event_info->launch_event.vector_length == tool_info->nested->event_info.launch_event.vector_length);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested->event_info.launch_event.kernel_name);
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_enter_data_start, cb_enter_data_start, acc_reg);
+ reg (acc_ev_enter_data_end, cb_enter_data_end, acc_reg);
+ reg (acc_ev_exit_data_start, cb_exit_data_start, acc_reg);
+ reg (acc_ev_exit_data_end, cb_exit_data_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
+ reg (acc_ev_enqueue_launch_end, cb_enqueue_launch_end, acc_reg);
+ assert (state == 0);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = acc_async_sync;
+ assert (state == 0);
+
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 4);
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ assert (state == 10);
+
+ STATE_OP (state, = 100);
+
+ acc_async = 12;
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 104);
+ }
+ assert (state == 110);
+
+ return 0;
+}
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
new file mode 100644
index 0000000..a952c7a
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
@@ -0,0 +1,172 @@
+/* Test the "valid_bytes" magic. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+void cb_data_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->data_event.valid_bytes == _ACC_DATA_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+void cb_launch_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+void cb_other_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_other_event, acc_reg);
+ reg_ (acc_ev_create, cb_data_event, acc_reg);
+ reg_ (acc_ev_delete, cb_data_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_data_event, acc_reg);
+ reg_ (acc_ev_free, cb_data_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_other_event, acc_reg);
+}
+
+/* Basic struct. */
+typedef struct A
+{
+ int a;
+ int b;
+#define VALID_BYTES_A \
+ _ACC_PROF_VALID_BYTES_STRUCT (A, b, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (int))
+} A;
+
+/* Add a "char" field. */
+typedef struct B
+{
+ int a;
+ int b;
+ char c;
+#define VALID_BYTES_B \
+ _ACC_PROF_VALID_BYTES_STRUCT (B, c, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} B;
+
+/* Add another "char" field. */
+typedef struct C
+{
+ int a;
+ int b;
+ char c, d;
+#define VALID_BYTES_C \
+ _ACC_PROF_VALID_BYTES_STRUCT (C, d, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} C;
+
+/* Add two "void *" fields. */
+typedef struct D
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+#define VALID_BYTES_D \
+ _ACC_PROF_VALID_BYTES_STRUCT (D, f, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} D;
+
+/* Add another three "char" fields. */
+typedef struct E
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+ char g, h, i;
+#define VALID_BYTES_E \
+ _ACC_PROF_VALID_BYTES_STRUCT (E, i, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} E;
+
+int main()
+{
+ A A1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof A1, VALID_BYTES_A);
+ assert (VALID_BYTES_A <= sizeof A1);
+ DEBUG_printf ("&A1=%p, &A1.b=%p\n", &A1, &A1.b);
+ assert (((char *) &A1) + VALID_BYTES_A == (char *) (&A1.b + 1));
+
+ B B1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof B1, VALID_BYTES_B);
+ assert (VALID_BYTES_B <= sizeof B1);
+ DEBUG_printf ("&B1=%p, &B1.c=%p\n", &B1, &B1.c);
+ assert (((char *) &B1) + VALID_BYTES_B == (char *) (&B1.c + 1));
+
+ assert (VALID_BYTES_B == VALID_BYTES_A + 1 * sizeof (char));
+
+ C C1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof C1, VALID_BYTES_C);
+ assert (VALID_BYTES_C <= sizeof C1);
+ DEBUG_printf ("&C1=%p, &C1.d=%p\n", &C1, &C1.d);
+ assert (((char *) &C1) + VALID_BYTES_C == (char *) (&C1.d + 1));
+
+ assert (VALID_BYTES_C == VALID_BYTES_B + 1 * sizeof (char));
+
+ D D1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof D1, VALID_BYTES_D);
+ assert (VALID_BYTES_D <= sizeof D1);
+ DEBUG_printf ("&D1=%p, &D1.f=%p\n", &D1, &D1.f);
+ assert (((char *) &D1) + VALID_BYTES_D == (char *) (&D1.f + 1));
+
+ assert (VALID_BYTES_D > VALID_BYTES_C);
+
+ E E1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof E1, VALID_BYTES_E);
+ assert (VALID_BYTES_E <= sizeof E1);
+ DEBUG_printf ("&E1=%p, &E1.i=%p\n", &E1, &E1.i);
+ assert (((char *) &E1) + VALID_BYTES_E == (char *) (&E1.i + 1));
+
+ assert (VALID_BYTES_E == VALID_BYTES_D + 3 * sizeof (char));
+
+#pragma acc parallel
+ {
+ }
+
+ return 0;
+}
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
new file mode 100644
index 0000000..b0b8934
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
@@ -0,0 +1,55 @@
+/* Test "acc_prof_info"'s "version" field. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+void cb_any_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->version == 201510);
+}
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_any_event, acc_reg);
+ reg_ (acc_ev_create, cb_any_event, acc_reg);
+ reg_ (acc_ev_delete, cb_any_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_any_event, acc_reg);
+ reg_ (acc_ev_free, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_any_event, acc_reg);
+}
+
+int main()
+{
+#pragma acc parallel
+ {
+ }
+
+ return 0;
+}
Grüße
Thomas
^ permalink raw reply [flat|nested] 23+ messages in thread
* More OpenACC 2.5 Profiling Interface (was: OpenACC 2.5 Profiling Interface (incomplete))
2017-02-28 17:54 OpenACC 2.5 Profiling Interface (incomplete) Thomas Schwinge
@ 2017-05-15 7:38 ` Thomas Schwinge
2017-05-15 11:55 ` Documentation changes for OpenACC 2.5 Profiling Interface (was: More OpenACC 2.5 Profiling Interface) Thomas Schwinge
2018-02-22 11:23 ` [og7] Fix hang when running oacc exec with CUDA 9.0 nvprof Tom de Vries
2018-11-12 4:32 ` OpenACC 2.5 Profiling Interface Thomas Schwinge
2 siblings, 1 reply; 23+ messages in thread
From: Thomas Schwinge @ 2017-05-15 7:38 UTC (permalink / raw)
To: gcc-patches
Hi!
On Tue, 28 Feb 2017 18:43:36 +0100, I wrote:
> The 2.5 versions of the OpenACC standard added a new chapter "Profiling
> Interface". In r245784, I committed incomplete support to
> gomp-4_0-branch. I plan to continue working on this, but wanted to
> synchronize at this point.
>
> commit b22a85fe7f3daeb48460e7aa28606d0cdb799f69
> Author: tschwinge <tschwinge@138bc75d-0d04-0410-961f-82ee72b054a4>
> Date: Tue Feb 28 17:36:03 2017 +0000
>
> OpenACC 2.5 Profiling Interface (incomplete)
Committed to gomp-4_0-branch in r248042:
commit e3720963a1f494b2a0a1b6c28d5eb8bfb7c0d546
Author: tschwinge <tschwinge@138bc75d-0d04-0410-961f-82ee72b054a4>
Date: Mon May 15 06:50:17 2017 +0000
More OpenACC 2.5 Profiling Interface
libgomp/
* oacc-async.c (acc_async_test, acc_async_test_all, acc_wait)
(acc_wait_async, acc_wait_all, acc_wait_all_async): Set up
profiling.
* oacc-cuda.c (acc_get_current_cuda_device)
(acc_get_current_cuda_context, acc_get_cuda_stream)
(acc_set_cuda_stream): Likewise.
* oacc-init.c (acc_set_device_type, acc_get_device_type)
(acc_get_device_num): Likewise.
* oacc-mem.c (acc_malloc, acc_free, memcpy_tofrom_device)
(acc_map_data, acc_unmap_data, present_create_copy)
(delete_copyout, update_dev_host): Likewise.
* oacc-parallel.c (GOACC_data_start, GOACC_data_end)
(GOACC_enter_exit_data, GOACC_update, GOACC_wait): Likewise.
* oacc-profiling.c (goacc_profiling_setup_p): New function.
(goacc_profiling_dispatch_p): Add a "bool" formal parameter.
Adjust all users.
* oacc-int.h (goacc_profiling_setup_p)
(goacc_profiling_dispatch_p): Update.
* plugin/plugin-nvptx.c (nvptx_exec, nvptx_wait, nvptx_wait_all):
Generate more profiling events.
* libgomp.texi (OpenACC Profiling Interface): Update.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/gomp-4_0-branch@248042 138bc75d-0d04-0410-961f-82ee72b054a4
---
libgomp/ChangeLog.gomp | 24 +++
libgomp/libgomp.texi | 74 +++++++--
libgomp/oacc-async.c | 110 ++++++++++++-
libgomp/oacc-cuda.c | 82 ++++++++--
libgomp/oacc-init.c | 102 +++++++++++-
libgomp/oacc-int.h | 4 +-
libgomp/oacc-mem.c | 154 +++++++++++++++++-
libgomp/oacc-parallel.c | 357 +++++++++++++++++++++++++++++++++++++++---
libgomp/oacc-profiling.c | 100 +++++++++++-
libgomp/plugin/plugin-nvptx.c | 113 ++++++++++++-
10 files changed, 1056 insertions(+), 64 deletions(-)
diff --git libgomp/ChangeLog.gomp libgomp/ChangeLog.gomp
index 5dc0889..23882cf 100644
--- libgomp/ChangeLog.gomp
+++ libgomp/ChangeLog.gomp
@@ -1,3 +1,27 @@
+2017-05-15 Thomas Schwinge <thomas@codesourcery.com>
+
+ * oacc-async.c (acc_async_test, acc_async_test_all, acc_wait)
+ (acc_wait_async, acc_wait_all, acc_wait_all_async): Set up
+ profiling.
+ * oacc-cuda.c (acc_get_current_cuda_device)
+ (acc_get_current_cuda_context, acc_get_cuda_stream)
+ (acc_set_cuda_stream): Likewise.
+ * oacc-init.c (acc_set_device_type, acc_get_device_type)
+ (acc_get_device_num): Likewise.
+ * oacc-mem.c (acc_malloc, acc_free, memcpy_tofrom_device)
+ (acc_map_data, acc_unmap_data, present_create_copy)
+ (delete_copyout, update_dev_host): Likewise.
+ * oacc-parallel.c (GOACC_data_start, GOACC_data_end)
+ (GOACC_enter_exit_data, GOACC_update, GOACC_wait): Likewise.
+ * oacc-profiling.c (goacc_profiling_setup_p): New function.
+ (goacc_profiling_dispatch_p): Add a "bool" formal parameter.
+ Adjust all users.
+ * oacc-int.h (goacc_profiling_setup_p)
+ (goacc_profiling_dispatch_p): Update.
+ * plugin/plugin-nvptx.c (nvptx_exec, nvptx_wait, nvptx_wait_all):
+ Generate more profiling events.
+ * libgomp.texi (OpenACC Profiling Interface): Update.
+
2017-05-14 Thomas Schwinge <thomas@codesourcery.com>
* testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c: New
diff --git libgomp/libgomp.texi libgomp/libgomp.texi
index 93365cd..b3fa139 100644
--- libgomp/libgomp.texi
+++ libgomp/libgomp.texi
@@ -3207,12 +3207,19 @@ Will be @code{acc_construct_parallel} for OpenACC kernels constructs;
should be @code{acc_construct_kernels}.
@item
+Will be @code{acc_construct_enter_data} or
+@code{acc_construct_exit_data} when processing variable mappings
+specified in OpenACC declare directives; should be
+@code{acc_construct_declare}.
+
+@item
For implicit @code{acc_ev_device_init_start},
@code{acc_ev_device_init_end}, and explicit as well as implicit
@code{acc_ev_alloc}, @code{acc_ev_free},
@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
-@code{acc_ev_enqueue_download_start}, and
-@code{acc_ev_enqueue_download_end}, will be
+@code{acc_ev_enqueue_download_start},
+@code{acc_ev_enqueue_download_end}, @code{acc_ev_wait_start}, and
+@code{acc_ev_wait_end}, will be
@code{acc_construct_parallel}; should reflect the real parent
construct.
@@ -3221,8 +3228,9 @@ construct.
@item @code{acc_event_info.*.implicit}
For @code{acc_ev_alloc}, @code{acc_ev_free},
@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
-@code{acc_ev_enqueue_download_start}, and
-@code{acc_ev_enqueue_download_end}, this currently will be @code{1}
+@code{acc_ev_enqueue_download_start},
+@code{acc_ev_enqueue_download_end}, @code{acc_ev_wait_start}, and
+@code{acc_ev_wait_end}, this currently will be @code{1}
also for explicit usage.
@item @code{acc_event_info.data_event.var_name}
@@ -3289,6 +3297,20 @@ it's not clear if they should be.
@end itemize
+@item @code{acc_ev_enter_data_start}, @code{acc_ev_enter_data_end}, @code{acc_ev_exit_data_start}, @code{acc_ev_exit_data_end}
+@itemize
+
+@item
+Callbacks for these event types will also be invoked for OpenACC
+host_data constructs; it's not clear if they should be.
+
+@item
+Callbacks for these event types will also be invoked when processing
+variable mappings specified in OpenACC declare directives; it's not
+clear if they should be.
+
+@end itemize
+
@end table
Callbacks for the following event types will be invoked, but dispatch
@@ -3297,8 +3319,10 @@ and information provided therein has not yet been thoroughly reviewed:
@itemize
@item @code{acc_ev_alloc}
@item @code{acc_ev_free}
+@item @code{acc_ev_update_start}, @code{acc_ev_update_end}
@item @code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end}
@item @code{acc_ev_enqueue_download_start}, @code{acc_ev_enqueue_download_end}
+@item @code{acc_ev_wait_start}, @code{acc_ev_wait_end}
@end itemize
During device initialization, and finalization, respectively,
@@ -3309,14 +3333,6 @@ callbacks for the following event types will not yet be invoked:
@item @code{acc_ev_free}
@end itemize
-Callbacks for the following event types will currently only be invoked
-for (implicit) events within compute constructs:
-
-@itemize
-@item @code{acc_ev_enter_data_start}, @code{acc_ev_enter_data_end}
-@item @code{acc_ev_exit_data_start}, @code{acc_ev_exit_data_end}
-@end itemize
-
Callbacks for the following event types have not yet been implemented,
so currently won't be invoked:
@@ -3324,8 +3340,38 @@ so currently won't be invoked:
@item @code{acc_ev_device_shutdown_start}, @code{acc_ev_device_shutdown_end}
@item @code{acc_ev_runtime_shutdown}
@item @code{acc_ev_create}, @code{acc_ev_delete}
-@item @code{acc_ev_update_start}, @code{acc_ev_update_end}
-@item @code{acc_ev_wait_start}, @code{acc_ev_wait_end}
+@end itemize
+
+For the following runtime library functions, not all expected
+callbacks will be invoked (mostly concerning implicit device
+initialization):
+
+@itemize
+@item @code{acc_get_num_devices}
+@item @code{acc_set_device_type}
+@item @code{acc_get_device_type}
+@item @code{acc_set_device_num}
+@item @code{acc_get_device_num}
+@item @code{acc_init}
+@item @code{acc_shutdown}
+@end itemize
+
+Aside from implicit device initialization, for the following runtime
+library functions, no callbacks will be invoked for shared-memory
+offloading devices (it's not clear if they should be):
+
+@itemize
+@item @code{acc_malloc}
+@item @code{acc_free}
+@item @code{acc_copyin}, @code{acc_present_or_copyin}, @code{acc_copyin_async}
+@item @code{acc_create}, @code{acc_present_or_create}, @code{acc_create_async}
+@item @code{acc_copyout}, @code{acc_copyout_async}
+@item @code{acc_delete}, @code{acc_delete_async}
+@item @code{acc_update_device}, @code{acc_update_device_async}
+@item @code{acc_update_self}, @code{acc_update_self_async}
+@item @code{acc_map_data}, @code{acc_unmap_data}
+@item @code{acc_memcpy_to_device}, @code{acc_memcpy_to_device_async}
+@item @code{acc_memcpy_from_device}, @code{acc_memcpy_from_device_async}
@end itemize
diff --git libgomp/oacc-async.c libgomp/oacc-async.c
index 921f943..7cefa0f 100644
--- libgomp/oacc-async.c
+++ libgomp/oacc-async.c
@@ -39,10 +39,30 @@ acc_async_test (int async)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
if (!thr || !thr->dev)
gomp_fatal ("no device active");
- return thr->dev->openacc.async_test_func (async);
+ int res = thr->dev->openacc.async_test_func (async);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return res;
}
int
@@ -50,10 +70,24 @@ acc_async_test_all (void)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
if (!thr || !thr->dev)
gomp_fatal ("no device active");
- return thr->dev->openacc.async_test_all_func ();
+ int res = thr->dev->openacc.async_test_all_func ();
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return res;
}
void
@@ -64,10 +98,28 @@ acc_wait (int async)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
if (!thr || !thr->dev)
gomp_fatal ("no device active");
thr->dev->openacc.async_wait_func (async);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -75,10 +127,28 @@ acc_wait_async (int async1, int async2)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async2; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
if (!thr || !thr->dev)
gomp_fatal ("no device active");
thr->dev->openacc.async_wait_async_func (async1, async2);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -86,10 +156,22 @@ acc_wait_all (void)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
if (!thr || !thr->dev)
gomp_fatal ("no device active");
thr->dev->openacc.async_wait_all_func ();
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -100,15 +182,36 @@ acc_wait_all_async (int async)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
if (!thr || !thr->dev)
gomp_fatal ("no device active");
thr->dev->openacc.async_wait_all_async_func (async);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
int
acc_get_default_async (void)
{
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
struct goacc_thread *thr = goacc_thread ();
if (!thr || !thr->dev)
@@ -120,6 +223,9 @@ acc_get_default_async (void)
void
acc_set_default_async (int async)
{
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
if (async < acc_async_sync)
gomp_fatal ("invalid async argument: %d", async);
diff --git libgomp/oacc-cuda.c libgomp/oacc-cuda.c
index 86a2a77..325fc8d 100644
--- libgomp/oacc-cuda.c
+++ libgomp/oacc-cuda.c
@@ -36,10 +36,23 @@ acc_get_current_cuda_device (void)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_device_func)
- return thr->dev->openacc.cuda.get_current_device_func ();
+ ret = thr->dev->openacc.cuda.get_current_device_func ();
- return NULL;
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return ret;
}
void *
@@ -47,10 +60,23 @@ acc_get_current_cuda_context (void)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_context_func)
- return thr->dev->openacc.cuda.get_current_context_func ();
-
- return NULL;
+ ret = thr->dev->openacc.cuda.get_current_context_func ();
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return ret;
}
void *
@@ -61,10 +87,29 @@ acc_get_cuda_stream (int async)
if (async < 0)
return NULL;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_stream_func)
- return thr->dev->openacc.cuda.get_stream_func (async);
+ ret = thr->dev->openacc.cuda.get_stream_func (async);
- return NULL;
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return ret;
}
int
@@ -79,8 +124,27 @@ acc_set_cuda_stream (int async, void *stream)
thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
+ int ret = -1;
if (thr && thr->dev && thr->dev->openacc.cuda.set_stream_func)
- return thr->dev->openacc.cuda.set_stream_func (async, stream);
+ ret = thr->dev->openacc.cuda.set_stream_func (async, stream);
- return -1;
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return ret;
}
diff --git libgomp/oacc-init.c libgomp/oacc-init.c
index 415c0fa..c262caa 100644
--- libgomp/oacc-init.c
+++ libgomp/oacc-init.c
@@ -220,8 +220,23 @@ acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)
static struct gomp_device_descr *
acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
{
+ bool check_not_nested_p;
+ if (implicit)
+ {
+ /* In the implicit case, there should (TODO: must?) already be something
+ have been set up for an outer construct. */
+ check_not_nested_p = false;
+ }
+ else
+ {
+ check_not_nested_p = true;
+ /* TODO: should we set "thr->prof_info" etc. in this case (acc_init)?
+ The problem is, that we don't have "thr" yet? (So,
+ "check_not_nested_p = true" also is pointless actually.) */
+ }
bool profiling_dispatch_p
- = __builtin_expect (goacc_profiling_dispatch_p (), false);
+ = __builtin_expect (goacc_profiling_dispatch_p (check_not_nested_p),
+ false);
acc_prof_info prof_info;
if (profiling_dispatch_p)
@@ -536,11 +551,21 @@ ialias (acc_shutdown)
int
acc_get_num_devices (acc_device_t d)
{
+#if 0 //TODO
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ prof_info.device_type = d; //TODO
+#endif
+
int n = 0;
struct gomp_device_descr *acc_dev;
if (d == acc_device_none)
- return 0;
+ goto out;
gomp_init_targets_once ();
@@ -549,12 +574,21 @@ acc_get_num_devices (acc_device_t d)
gomp_mutex_unlock (&acc_device_lock);
if (!acc_dev)
- return 0;
+ goto out;
n = acc_dev->get_num_devices_func ();
if (n < 0)
n = 0;
+ out:
+#if 0 //TODO
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+#endif
+
return n;
}
@@ -570,6 +604,14 @@ acc_set_device_type (acc_device_t d)
struct gomp_device_descr *base_dev, *acc_dev;
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ prof_info.device_type = d; //TODO
+
gomp_mutex_lock (&acc_device_lock);
if (!cached_base_dev)
@@ -595,6 +637,12 @@ acc_set_device_type (acc_device_t d)
}
goacc_attach_host_thread_to_device (-1);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
ialias (acc_set_device_type)
@@ -610,12 +658,25 @@ acc_get_device_type (void)
res = acc_device_type (thr->base_dev->type);
else
{
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr,
+ &prof_info, &api_info),
+ false);
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (acc_device_default, true);
gomp_mutex_unlock (&acc_device_lock);
res = acc_device_type (dev->type);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
assert (res != acc_device_default
@@ -632,6 +693,14 @@ acc_get_device_num (acc_device_t d)
const struct gomp_device_descr *dev;
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ prof_info.device_type = d; //TODO
+
if (d >= _ACC_device_hwm)
gomp_fatal ("unknown device type %u", (unsigned) d);
@@ -642,6 +711,12 @@ acc_get_device_num (acc_device_t d)
dev = resolve_device (d, true);
gomp_mutex_unlock (&acc_device_lock);
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
if (thr && thr->base_dev == dev && thr->dev)
return thr->dev->target_id;
@@ -653,6 +728,19 @@ ialias (acc_get_device_num)
void
acc_set_device_num (int ord, acc_device_t d)
{
+#if 0 //TODO
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.device_type = d; //TODO
+ prof_info.device_type = ord; //TODO
+ }
+#endif
+
struct gomp_device_descr *base_dev, *acc_dev;
int num_devices;
@@ -691,6 +779,14 @@ acc_set_device_num (int ord, acc_device_t d)
}
goacc_device_num = ord;
+
+#if 0 //TODO
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+#endif
}
ialias (acc_set_device_num)
diff --git libgomp/oacc-int.h libgomp/oacc-int.h
index 8a62029..7f83516 100644
--- libgomp/oacc-int.h
+++ libgomp/oacc-int.h
@@ -110,7 +110,9 @@ void goacc_lazy_initialize (void);
void goacc_host_init (void);
void goacc_profiling_initialize (void);
-bool goacc_profiling_dispatch_p (void);
+bool goacc_profiling_setup_p (struct goacc_thread *,
+ acc_prof_info *, acc_api_info *);
+bool goacc_profiling_dispatch_p (bool);
void goacc_profiling_dispatch (acc_prof_info *, acc_event_info *,
acc_api_info *);
diff --git libgomp/oacc-mem.c libgomp/oacc-mem.c
index 17e02b2..fd0dac4 100644
--- libgomp/oacc-mem.c
+++ libgomp/oacc-mem.c
@@ -103,12 +103,30 @@ acc_malloc (size_t s)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
assert (thr->dev);
+ void *ret;
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- return malloc (s);
+ {
+ /* TODO: Should we also generate acc_ev_alloc here? */
+ ret = malloc (s);
+ }
+ else
+ ret = thr->dev->alloc_func (thr->dev->target_id, s);
- return thr->dev->alloc_func (thr->dev->target_id, s);
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return ret;
}
/* OpenACC 2.0a (3.2.16) doesn't specify what to do in the event
@@ -124,12 +142,23 @@ acc_free (void *d)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
assert (thr && thr->dev);
struct gomp_device_descr *acc_dev = thr->dev;
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- return free (d);
+ {
+ /* TODO: Should we also generate acc_ev_free here? */
+ free (d);
+
+ goto out;
+ }
gomp_mutex_lock (&acc_dev->lock);
@@ -151,6 +180,13 @@ acc_free (void *d)
if (!acc_dev->free_func (acc_dev->target_id, d))
gomp_fatal ("error in freeing device memory in %s", __FUNCTION__);
+
+ out:
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
@@ -161,15 +197,31 @@ memcpy_tofrom_device (bool from, void *d, void *h, size_t s, int async,
been obtained from a routine that did that. */
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
assert (thr && thr->dev);
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
{
+ /* TODO: Should we also generate
+ acc_ev_enqueue_upload_start/acc_ev_enqueue_upload_end or
+ acc_ev_enqueue_download_start/acc_ev_enqueue_download_end here? */
if (from)
memmove (h, d, s);
else
memmove (d, h, s);
- return;
+
+ goto out;
}
if (async > acc_async_sync)
@@ -184,6 +236,13 @@ memcpy_tofrom_device (bool from, void *d, void *h, size_t s, int async,
if (!ret)
gomp_fatal ("error in %s", libfnname);
+
+ out:
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -228,6 +287,9 @@ acc_deviceptr (void *h)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&dev->lock);
n = lookup_host (dev, h, 1);
@@ -265,6 +327,9 @@ acc_hostptr (void *d)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return d;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_dev (acc_dev->openacc.data_environ, d, 1);
@@ -302,6 +367,9 @@ acc_is_present (void *h, size_t s)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h != NULL;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -333,6 +401,12 @@ acc_map_data (void *h, void *d, size_t s)
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
{
if (d != h)
@@ -372,6 +446,12 @@ acc_map_data (void *h, void *d, size_t s)
tgt->prev = acc_dev->openacc.data_environ;
acc_dev->openacc.data_environ = tgt;
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -386,6 +466,12 @@ acc_unmap_data (void *h)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
size_t host_size;
gomp_mutex_lock (&acc_dev->lock);
@@ -436,6 +522,12 @@ acc_unmap_data (void *h)
gomp_mutex_unlock (&acc_dev->lock);
gomp_unmap_vars (t, true);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
#define FLAG_PRESENT (1 << 0)
@@ -459,6 +551,18 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -518,6 +622,12 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
gomp_mutex_unlock (&acc_dev->lock);
}
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return d;
}
@@ -582,6 +692,18 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -622,6 +744,12 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
if (!acc_dev->free_func (acc_dev->target_id, d))
gomp_fatal ("error in freeing device memory in %s", libfnname);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -664,6 +792,18 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
gomp_mutex_lock (&acc_dev->lock);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
n = lookup_host (acc_dev, h, s);
if (!n)
@@ -687,6 +827,12 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
acc_dev->openacc.async_set_async_func (acc_async_sync);
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
diff --git libgomp/oacc-parallel.c libgomp/oacc-parallel.c
index de70ac0..bff62ba 100644
--- libgomp/oacc-parallel.c
+++ libgomp/oacc-parallel.c
@@ -143,7 +143,7 @@ GOACC_parallel_keyed (int device, void (*fn) (void *),
acc_dev = thr->dev;
bool profiling_dispatch_p
- = __builtin_expect (goacc_profiling_dispatch_p (), false);
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
acc_prof_info prof_info;
if (profiling_dispatch_p)
@@ -407,18 +407,86 @@ GOACC_data_start (int device, size_t mapnum,
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_enter_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info enter_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ enter_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_data_event_info.other_event.parent_construct = acc_construct_data;
+ for (int i = 0; i < mapnum; ++i)
+ if (kinds[i] == GOMP_MAP_USE_DEVICE_PTR)
+ {
+ /* If there is one such data mapping kind, then this is actually an
+ OpenACC host_data construct. (GCC maps the OpenACC host_data
+ construct to the OpenACC data construct.) Apart from artificial
+ test cases (such as an OpenACC host_data construct's (implicit)
+ device initialization when there hasn't been any device data be
+ set up before...), there can't really any meaningful events be
+ generated from OpenACC host_data constructs, though. */
+ enter_data_event_info.other_event.parent_construct
+ = acc_construct_host_data;
+ break;
+ }
+ enter_data_event_info.other_event.implicit = 0;
+ enter_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds);
/* Host fallback or 'do nothing'. */
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| host_fallback)
{
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
tgt = gomp_map_vars (NULL, 0, NULL, NULL, NULL, NULL, true,
GOMP_MAP_VARS_OPENACC);
tgt->prev = thr->mapped_data;
thr->mapped_data = tgt;
-
- return;
+ goto out;
}
gomp_debug (0, " %s: prepare mappings\n", __FUNCTION__);
@@ -427,18 +495,92 @@ GOACC_data_start (int device, size_t mapnum,
gomp_debug (0, " %s: mappings prepared\n", __FUNCTION__);
tgt->prev = thr->mapped_data;
thr->mapped_data = tgt;
+
+ out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_data_end (void)
{
struct goacc_thread *thr = goacc_thread ();
+ struct gomp_device_descr *acc_dev = thr->dev;
struct target_mem_desc *tgt = thr->mapped_data;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ exit_data_event_info.other_event.parent_construct = acc_construct_data;
+ exit_data_event_info.other_event.implicit = 0;
+ exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
gomp_debug (0, " %s: restore mappings\n", __FUNCTION__);
thr->mapped_data = tgt->prev;
gomp_unmap_vars (tgt, true);
gomp_debug (0, " %s: mappings restored\n", __FUNCTION__);
+
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_end;
+ exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -452,26 +594,6 @@ GOACC_enter_exit_data (int device, size_t mapnum,
bool data_enter = false;
size_t i;
- goacc_lazy_initialize ();
-
- thr = goacc_thread ();
- acc_dev = thr->dev;
-
- if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- || host_fallback)
- return;
-
- if (num_waits)
- {
- va_list ap;
-
- va_start (ap, num_waits);
- goacc_wait (async, num_waits, &ap);
- va_end (ap);
- }
-
- acc_dev->openacc.async_set_async_func (async);
-
/* Determine if this is an "acc enter data". */
for (i = 0; i < mapnum; ++i)
{
@@ -501,6 +623,86 @@ GOACC_enter_exit_data (int device, size_t mapnum,
kind);
}
+ goacc_lazy_initialize ();
+
+ thr = goacc_thread ();
+ acc_dev = thr->dev;
+
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type
+ = data_enter ? acc_ev_enter_data_start : acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = data_enter ? acc_construct_enter_data : acc_construct_exit_data;
+ enter_exit_data_event_info.other_event.implicit = 0;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
+ || host_fallback)
+ {
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+ goto out;
+ }
+
+ if (num_waits)
+ {
+ va_list ap;
+
+ va_start (ap, num_waits);
+ goacc_wait (async, num_waits, &ap);
+ va_end (ap);
+ }
+
+ acc_dev->openacc.async_set_async_func (async);
+
/* In c, non-pointers and arrays are represented by a single data clause.
Dynamically allocated arrays and subarrays are represented by a data
clause followed by an internal GOMP_MAP_POINTER.
@@ -603,6 +805,18 @@ GOACC_enter_exit_data (int device, size_t mapnum,
}
acc_dev->openacc.async_set_async_func (acc_async_sync);
+
+ out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = data_enter ? acc_ev_enter_data_end: acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
@@ -642,9 +856,66 @@ GOACC_update (int device, size_t mapnum,
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_update_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info update_event_info;
+ if (profiling_dispatch_p)
+ {
+ update_event_info.other_event.event_type
+ = prof_info.event_type;
+ update_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ update_event_info.other_event.parent_construct = acc_construct_update;
+ update_event_info.other_event.implicit = 0;
+ update_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| host_fallback)
- return;
+ {
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+ goto out;
+ }
if (num_waits)
{
@@ -718,11 +989,41 @@ GOACC_update (int device, size_t mapnum,
}
acc_dev->openacc.async_set_async_func (acc_async_sync);
+
+ out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_update_end;
+ update_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_wait (int async, int num_waits, ...)
{
+ goacc_lazy_initialize ();
+
+ struct goacc_thread *thr = goacc_thread ();
+
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
if (num_waits)
{
va_list ap;
@@ -734,7 +1035,13 @@ GOACC_wait (int async, int num_waits, ...)
else if (async == acc_async_sync)
acc_wait_all ();
else if (async == acc_async_noval)
- goacc_thread ()->dev->openacc.async_wait_all_async_func (acc_async_noval);
+ thr->dev->openacc.async_wait_all_async_func (acc_async_noval);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
int
diff --git libgomp/oacc-profiling.c libgomp/oacc-profiling.c
index a4671f9..35d652c 100644
--- libgomp/oacc-profiling.c
+++ libgomp/oacc-profiling.c
@@ -485,10 +485,90 @@ acc_prof_unregister (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
gomp_mutex_unlock (&goacc_prof_lock);
}
+/* Set up to dispatch events? */
+
+bool
+goacc_profiling_setup_p (struct goacc_thread *thr,
+ acc_prof_info *prof_info, acc_api_info *api_info)
+{
+ //TODO
+ gomp_debug (0, "%s (%p)\n", __FUNCTION__, thr);
+
+ /* If we don't have any per-thread state yet, we can't register prof_info and
+ api_info. */
+ /* TODO: In this case, should we actually call goacc_lazy_initialize here,
+ and return the "thr" from goacc_profiling_setup_p? */
+ if (__builtin_expect (thr == NULL, false))
+ {
+ //TODO
+ gomp_debug (0, "Can't generate OpenACC Profiling Interface events for"
+ " the current call, construct, or directive\n");
+ return false;
+ }
+
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (false), false);
+ if (thr->prof_info != NULL)
+ {
+ assert (profiling_dispatch_p); //TODO
+ /* Profiling has already been set up for an outer construct. In this
+ case, we continue to use the existing information, and thus return
+ "false" here.
+
+ This can happen, for example, for an enter data directive, which sets
+ up profiling, then calls into acc_copyin, which should not again set
+ up profiling, should not overwrite the existing information. */
+ //TODO: Is this all kosher?
+ return false;
+ }
+
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = prof_info;
+
+ prof_info->event_type = -1; /* Must be set later. */
+ prof_info->valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info->version = _ACC_PROF_INFO_VERSION;
+ //TODO
+ if (thr->dev)
+ {
+ prof_info->device_type = acc_device_type (thr->dev->type);
+ prof_info->device_number = thr->dev->target_id;
+ }
+ else
+ {
+ prof_info->device_type = -1;
+ prof_info->device_number = -1;
+ }
+ prof_info->thread_id = -1; //TODO
+ prof_info->async = acc_async_sync; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info->async_queue = prof_info->async;
+ prof_info->src_file = NULL; //TODO
+ prof_info->func_name = NULL; //TODO
+ prof_info->line_no = -1; //TODO
+ prof_info->end_line_no = -1; //TODO
+ prof_info->func_line_no = -1; //TODO
+ prof_info->func_end_line_no = -1; //TODO
+
+ thr->api_info = api_info;
+
+ api_info->device_api = acc_device_api_none; //TODO
+ api_info->valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info->device_type = prof_info->device_type;
+ api_info->vendor = -1; //TODO
+ api_info->device_handle = NULL; //TODO
+ api_info->context_handle = NULL; //TODO
+ api_info->async_handle = NULL; //TODO
+ }
+
+ return profiling_dispatch_p;
+}
+
/* Prepare to dispatch events? */
bool
-goacc_profiling_dispatch_p (void)
+goacc_profiling_dispatch_p (bool check_not_nested_p)
{
//TODO
gomp_debug (0, "%s\n", __FUNCTION__);
@@ -504,11 +584,21 @@ goacc_profiling_dispatch_p (void)
//TODO
gomp_debug (0, " %s: don't have any per-thread state yet\n", __FUNCTION__);
}
- else if (__builtin_expect (!thr->prof_callbacks_enabled, true))
+ else
{
- //TODO
- gomp_debug (0, " %s: disabled for this thread\n", __FUNCTION__);
- return false;
+ if (check_not_nested_p)
+ {
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ }
+
+ if (__builtin_expect (!thr->prof_callbacks_enabled, true))
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled for this thread\n", __FUNCTION__);
+ return false;
+ }
}
gomp_mutex_lock (&goacc_prof_lock);
diff --git libgomp/plugin/plugin-nvptx.c libgomp/plugin/plugin-nvptx.c
index dbea9da..a9d1f16 100644
--- libgomp/plugin/plugin-nvptx.c
+++ libgomp/plugin/plugin-nvptx.c
@@ -1275,10 +1275,38 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
api_info);
}
+ acc_event_info wait_event_info;
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_wait_start;
+
+ wait_event_info.other_event.event_type = prof_info->event_type;
+ wait_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ wait_event_info.other_event.parent_construct
+ /* TODO = compute_construct_event_info.other_event.parent_construct */
+ = acc_construct_parallel; //TODO: kernels...
+ wait_event_info.other_event.implicit = 1;
+ wait_event_info.other_event.tool_info = NULL;
+
+ api_info->device_api = acc_device_api_cuda;
+ }
#ifndef DISABLE_ASYNC
if (async < acc_async_noval)
{
+ if (profiling_dispatch_p)
+ {
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &wait_event_info,
+ api_info);
+ }
r = cuStreamSynchronize (dev_str->stream);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_wait_end;
+ wait_event_info.other_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &wait_event_info,
+ api_info);
+ }
if (r == CUDA_ERROR_LAUNCH_FAILED)
GOMP_PLUGIN_fatal ("cuStreamSynchronize error: %s %s\n", cuda_error (r),
maybe_abort_msg);
@@ -1305,7 +1333,19 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
event_add (PTX_EVT_KNL, e, (void *)dev_str, 0);
}
#else
+ if (profiling_dispatch_p)
+ {
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &wait_event_info,
+ api_info);
+ }
r = cuCtxSynchronize ();
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_wait_end;
+ wait_event_info.other_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &wait_event_info,
+ api_info);
+ }
if (r == CUDA_ERROR_LAUNCH_FAILED)
GOMP_PLUGIN_fatal ("cuCtxSynchronize error: %s %s\n", cuda_error (r),
maybe_abort_msg);
@@ -1664,7 +1704,44 @@ nvptx_wait (int async)
GOMP_PLUGIN_debug (0, " %s: waiting on async=%d\n", __FUNCTION__, async);
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ bool profiling_dispatch_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ acc_event_info wait_event_info;
+ if (profiling_dispatch_p)
+ {
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_wait_start;
+
+ wait_event_info.other_event.event_type = prof_info->event_type;
+ wait_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ wait_event_info.other_event.parent_construct
+ /* TODO = compute_construct_event_info.other_event.parent_construct */
+ = acc_construct_parallel; //TODO: kernels...
+ wait_event_info.other_event.implicit = 1;
+ wait_event_info.other_event.tool_info = NULL;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &wait_event_info,
+ api_info);
+ }
CUDA_CALL_ASSERT (cuStreamSynchronize, s->stream);
+ if (profiling_dispatch_p)
+ {
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_wait_end;
+
+ wait_event_info.other_event.event_type = prof_info->event_type;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &wait_event_info,
+ api_info);
+ }
event_gc (true);
}
@@ -1706,10 +1783,28 @@ nvptx_wait_all (void)
CUresult r;
struct ptx_stream *s;
pthread_t self = pthread_self ();
- struct nvptx_thread *nvthd = nvptx_thread ();
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ struct nvptx_thread *nvthd = (struct nvptx_thread *) thr->target_tls;
pthread_mutex_lock (&nvthd->ptx_dev->stream_lock);
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info wait_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ wait_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ wait_event_info.other_event.parent_construct
+ /* TODO = compute_construct_event_info.other_event.parent_construct */
+ = acc_construct_parallel; //TODO: kernels...
+ wait_event_info.other_event.implicit = 1;
+ wait_event_info.other_event.tool_info = NULL;
+
+ api_info->device_api = acc_device_api_cuda;
+ }
+
/* Wait for active streams initiated by this thread (or by multiple threads)
to complete. */
for (s = nvthd->ptx_dev->active_streams; s != NULL; s = s->next)
@@ -1722,7 +1817,23 @@ nvptx_wait_all (void)
else if (r != CUDA_ERROR_NOT_READY)
GOMP_PLUGIN_fatal ("cuStreamQuery error: %s", cuda_error (r));
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_wait_start;
+ wait_event_info.other_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info,
+ &wait_event_info,
+ api_info);
+ }
CUDA_CALL_ASSERT (cuStreamSynchronize, s->stream);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_wait_end;
+ wait_event_info.other_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info,
+ &wait_event_info,
+ api_info);
+ }
}
}
Grüße
Thomas
^ permalink raw reply [flat|nested] 23+ messages in thread
* Documentation changes for OpenACC 2.5 Profiling Interface (was: More OpenACC 2.5 Profiling Interface)
2017-05-15 7:38 ` More OpenACC 2.5 Profiling Interface (was: OpenACC 2.5 Profiling Interface (incomplete)) Thomas Schwinge
@ 2017-05-15 11:55 ` Thomas Schwinge
0 siblings, 0 replies; 23+ messages in thread
From: Thomas Schwinge @ 2017-05-15 11:55 UTC (permalink / raw)
To: gcc-patches
Hi!
On Mon, 15 May 2017 08:52:39 +0200, I wrote:
> On Tue, 28 Feb 2017 18:43:36 +0100, I wrote:
> > The 2.5 versions of the OpenACC standard added a new chapter "Profiling
> > Interface". In r245784, I committed incomplete support to
> > gomp-4_0-branch. I plan to continue working on this, but wanted to
> > synchronize at this point.
> >
> > commit b22a85fe7f3daeb48460e7aa28606d0cdb799f69
> > Author: tschwinge <tschwinge@138bc75d-0d04-0410-961f-82ee72b054a4>
> > Date: Tue Feb 28 17:36:03 2017 +0000
> >
> > OpenACC 2.5 Profiling Interface (incomplete)
>
> Committed to gomp-4_0-branch in r248042:
>
> commit e3720963a1f494b2a0a1b6c28d5eb8bfb7c0d546
> Author: tschwinge <tschwinge@138bc75d-0d04-0410-961f-82ee72b054a4>
> Date: Mon May 15 06:50:17 2017 +0000
>
> More OpenACC 2.5 Profiling Interface
Committed to gomp-4_0-branch in r248058:
commit b58008024048f960eedffff9fd709cbe5d5ea96c
Author: tschwinge <tschwinge@138bc75d-0d04-0410-961f-82ee72b054a4>
Date: Mon May 15 11:45:45 2017 +0000
Documentation changes for OpenACC 2.5 Profiling Interface
libgomp/
* libgomp.texi (OpenACC Environment Variables): Mention
"ACC_PROFLIB".
(OpenACC Profiling Interface): Update.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/gomp-4_0-branch@248058 138bc75d-0d04-0410-961f-82ee72b054a4
---
libgomp/ChangeLog.gomp | 4 ++++
libgomp/libgomp.texi | 21 ++++++++++++++++++---
2 files changed, 22 insertions(+), 3 deletions(-)
diff --git libgomp/ChangeLog.gomp libgomp/ChangeLog.gomp
index f36cbfc..3125c99 100644
--- libgomp/ChangeLog.gomp
+++ libgomp/ChangeLog.gomp
@@ -1,5 +1,9 @@
2017-05-15 Thomas Schwinge <thomas@codesourcery.com>
+ * libgomp.texi (OpenACC Environment Variables): Mention
+ "ACC_PROFLIB".
+ (OpenACC Profiling Interface): Update.
+
* libgomp.texi: Update for OpenACC 2.5.
* openacc.f90 (openacc_version): Update to "201510".
* openacc_lib.h (openacc_version): Likewise.
diff --git libgomp/libgomp.texi libgomp/libgomp.texi
index 74b98c7..7a3c491 100644
--- libgomp/libgomp.texi
+++ libgomp/libgomp.texi
@@ -2839,13 +2839,15 @@ A.2.1.4.
@node OpenACC Environment Variables
@chapter OpenACC Environment Variables
-The variables @env{ACC_DEVICE_TYPE} and @env{ACC_DEVICE_NUM}
+The variables @env{ACC_DEVICE_TYPE}, @env{ACC_DEVICE_NUM},
+and @code{ACC_PROFLIB}
are defined by section 4 of the OpenACC specification in version 2.5.
The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
@menu
* ACC_DEVICE_TYPE::
* ACC_DEVICE_NUM::
+* ACC_PROFLIB::
* GCC_ACC_NOTIFY::
@end menu
@@ -2871,6 +2873,19 @@ The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
+@node ACC_PROFLIB
+@section @code{ACC_PROFLIB}
+@table @asis
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{http://www.openacc.org/, OpenACC specification v2.5}, section
+4.3.
+@end table
+
+
+
@node GCC_ACC_NOTIFY
@section @code{GCC_ACC_NOTIFY}
@table @asis
@@ -3095,8 +3110,8 @@ Application Programming Interface}, version 2.5.}
@section Implementation Status and Implementation-Defined Behavior
-We're not yet implementing the whole Profiling Interface as defined by
-the OpenACC 2.5 specification. Also, the specification doesn't
+We're implementing most of the Profiling Interface as defined by
+the OpenACC 2.5 specification. The specification doesn't
clearly define some aspects of its Profiling Interface, so we're
clarifying these as @emph{implementation-defined behavior} here. We
already have reported to the OpenACC Technical Committee some issues,
Grüße
Thomas
^ permalink raw reply [flat|nested] 23+ messages in thread
* [og7] Fix hang when running oacc exec with CUDA 9.0 nvprof
@ 2018-02-22 11:23 ` Tom de Vries
2020-03-25 17:09 ` [og9] Fix og9 "Fix hang when running oacc exec with CUDA 9.0 nvprof" Thomas Schwinge
2020-07-13 15:29 ` [PATCH] libgomp: Fix hang when profiling OpenACC programs with CUDA 9.0 nvprof Kwok Cheung Yeung
0 siblings, 2 replies; 23+ messages in thread
From: Tom de Vries @ 2018-02-22 11:23 UTC (permalink / raw)
To: GCC Patches; +Cc: Thomas Schwinge, Jakub Jelinek
[-- Attachment #1: Type: text/plain, Size: 1102 bytes --]
Hi,
when using cuda 9 nvprof with an openacc executable, the executable hangs.
The scenario resulting in the hang is as follows:
1. goacc_lazy_initialize calls gomp_mutex_lock (&acc_device_lock)
2. goacc_lazy_initialize calls acc_init_1
3. acc_init_1 calls goacc_profiling_dispatch (&prof_info,
&device_init_event_info, &api_info);
4. goacc_profiling_dispatch calls the registered callback in the cuda
profiling library
5. the registered call back calls acc_get_device_type
6. acc_get_device_type calls gomp_mutex_lock (&acc_device_lock)
7. The lock is not recursive, so we have deadlock
The registered callback in cuda 8 does not call acc_get_device_type, so
the hang doesn't occur there.
This patch fixes the hang by detecting in acc_get_device_type that the
calling thread is a thread that is currently initializing the openacc
part of the libgomp library, and returning acc_device_none, which is a
legal value given that the openacc standard states "If the device type
has not yet been selected, the value acc_device_none may be returned".
Committed to og7 branch.
Thanks,
- Tom
[-- Attachment #2: 0001-Fix-hang-when-running-oacc-exec-with-CUDA-9.0-nvprof.patch --]
[-- Type: text/x-patch, Size: 3035 bytes --]
Fix hang when running oacc exec with CUDA 9.0 nvprof
2018-02-15 Tom de Vries <tom@codesourcery.com>
* oacc-init.c (acc_init_state_lock, acc_init_state, acc_init_thread):
New variable.
(acc_init_1): Set acc_init_thread to pthread_self (). Set
acc_init_state to initializing at the start, and to initialized at the
end.
(self_initializing_p): New function.
(acc_get_device_type): Return acc_device_none if called by thread that
is currently executing acc_init_1.
---
libgomp/oacc-init.c | 33 +++++++++++++++++++++++++++++++++
2 files changed, 44 insertions(+)
diff --git a/libgomp/oacc-init.c b/libgomp/oacc-init.c
index 6dada0b..d8348c0 100644
--- a/libgomp/oacc-init.c
+++ b/libgomp/oacc-init.c
@@ -40,6 +40,11 @@
static gomp_mutex_t acc_device_lock;
+static gomp_mutex_t acc_init_state_lock;
+static enum { uninitialized, initializing, initialized } acc_init_state
+ = uninitialized;
+static pthread_t acc_init_thread;
+
/* A cached version of the dispatcher for the global "current" accelerator type,
e.g. used as the default when creating new host threads. This is the
device-type equivalent of goacc_device_num (which specifies which device to
@@ -220,6 +225,11 @@ acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)
static struct gomp_device_descr *
acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
{
+ gomp_mutex_lock (&acc_init_state_lock);
+ acc_init_state = initializing;
+ acc_init_thread = pthread_self ();
+ gomp_mutex_unlock (&acc_init_state_lock);
+
bool check_not_nested_p;
if (implicit)
{
@@ -312,6 +322,9 @@ acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
&api_info);
}
+ gomp_mutex_lock (&acc_init_state_lock);
+ acc_init_state = initialized;
+ gomp_mutex_unlock (&acc_init_state_lock);
return base_dev;
}
@@ -644,6 +657,17 @@ acc_set_device_type (acc_device_t d)
ialias (acc_set_device_type)
+static bool
+self_initializing_p (void)
+{
+ bool res;
+ gomp_mutex_lock (&acc_init_state_lock);
+ res = (acc_init_state == initializing
+ && pthread_equal (acc_init_thread, pthread_self ()));
+ gomp_mutex_unlock (&acc_init_state_lock);
+ return res;
+}
+
acc_device_t
acc_get_device_type (void)
{
@@ -653,6 +677,15 @@ acc_get_device_type (void)
if (thr && thr->base_dev)
res = acc_device_type (thr->base_dev->type);
+ else if (self_initializing_p ())
+ /* The Cuda libaccinj64.so version 9.0+ calls acc_get_device_type during the
+ acc_ev_device_init_start event callback, which is dispatched during
+ acc_init_1. Trying to lock acc_device_lock during such a call (as we do
+ in the else clause below), will result in deadlock, since the lock has
+ already been taken by the acc_init_1 caller. We work around this problem
+ by using the acc_get_device_type property "If the device type has not yet
+ been selected, the value acc_device_none may be returned". */
+ ;
else
{
acc_prof_info prof_info;
^ permalink raw reply [flat|nested] 23+ messages in thread
* OpenACC 2.5 Profiling Interface
2017-02-28 17:54 OpenACC 2.5 Profiling Interface (incomplete) Thomas Schwinge
2017-05-15 7:38 ` More OpenACC 2.5 Profiling Interface (was: OpenACC 2.5 Profiling Interface (incomplete)) Thomas Schwinge
2018-02-22 11:23 ` [og7] Fix hang when running oacc exec with CUDA 9.0 nvprof Tom de Vries
@ 2018-11-12 4:32 ` Thomas Schwinge
2018-12-04 13:13 ` Jakub Jelinek
2019-05-16 15:22 ` OpenACC Profiling Interface: 'acc_register_library' (was: OpenACC 2.5 Profiling Interface) Thomas Schwinge
2 siblings, 2 replies; 23+ messages in thread
From: Thomas Schwinge @ 2018-11-12 4:32 UTC (permalink / raw)
To: gcc-patches, Jakub Jelinek
Hi!
On Tue, 28 Feb 2017 18:43:36 +0100, I wrote:
> The 2.5 versions of the OpenACC standard added a new chapter "Profiling
> Interface".
I'd like to get that into trunk. It's not yet complete (that is, doesn't
provide all the information specified), but it's very useful already, and
the missing pieces can later be added incrementally.
Jakub, would you please especially review the non-OpenACC-specific
changes here, including the libgomp ABI changes?
(Note that this patch doesn't apply on top of trunk. I extracted it out
of openacc-gcc-8-branch, plus additional changes, and it depends on a
number of other pending patches. Due to the many regions of code
touched, there are a lot of "textual" conflicts when porting it to
current trunk, but the "structure" will be the same.)
libgomp/Makefile.am | 18 +-
libgomp/acc_prof.h | 235 +++++++
libgomp/env.c | 2 +
libgomp/libgomp-plugin.c | 9 +
libgomp/libgomp-plugin.h | 6 +
libgomp/libgomp.map | 10 +
libgomp/libgomp.texi | 307 ++++++++-
libgomp/oacc-async.c | 97 +++
libgomp/oacc-cuda.c | 72 +-
libgomp/oacc-init.c | 131 +++-
libgomp/oacc-int.h | 22 +-
libgomp/oacc-mem.c | 213 +++++-
libgomp/oacc-parallel.c | 427 +++++++++++-
libgomp/oacc-plugin.c | 13 +
libgomp/oacc-plugin.h | 3 +
libgomp/oacc-profiling-acc_register_library.c | 39 ++
libgomp/oacc-profiling-locinfo.c | 138 ++++
libgomp/oacc-profiling.c | 650 ++++++++++++++++++
libgomp/plugin/plugin-nvptx.c | 144 ++++
.../acc_prof-dispatch-1.c | 350 ++++++++++
.../acc_prof-init-1-debug_info.c | 5 +
.../libgomp.oacc-c-c++-common/acc_prof-init-1.c | 388 +++++++++++
.../libgomp.oacc-c-c++-common/acc_prof-kernels-1.c | 252 +++++++
.../acc_prof-parallel-1-debug_info.c | 5 +
.../acc_prof-parallel-1.c | 737 +++++++++++++++++++++
.../acc_prof-valid_bytes-1.c | 178 +++++
.../libgomp.oacc-c-c++-common/acc_prof-version-1.c | 60 ++
32 files changed, 4466 insertions(+), 81 deletions(-)
diff --git libgomp/Makefile.am libgomp/Makefile.am
index 8446b8d82c6d..eb0d58cb5103 100644
--- libgomp/Makefile.am
+++ libgomp/Makefile.am
@@ -13,11 +13,12 @@ search_path = $(addprefix $(top_srcdir)/config/, $(config_path)) $(top_srcdir) \
fincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)$(MULTISUBDIR)/finclude
libsubincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)/include
+libgomp_la_LIBADD =
+
LIBFFI = @LIBFFI@
LIBFFIINCS = @LIBFFIINCS@
if USE_LIBFFI
-libgomp_la_LIBADD = $(LIBFFI)
+libgomp_la_LIBADD += $(LIBFFI)
endif
vpath % $(strip $(search_path))
@@ -26,6 +27,13 @@ AM_CPPFLAGS = $(addprefix -I, $(search_path)) $(LIBFFIINCS)
AM_CFLAGS = $(XCFLAGS)
AM_LDFLAGS = $(XLDFLAGS) $(SECTION_LDFLAGS) $(OPT_LDFLAGS)
+#TODO Probably have to specify dependency in the top-level build system, too.
+libgomp_la_LIBADD += ../libbacktrace/libbacktrace.la
+AM_CPPFLAGS += \
+ -I$(srcdir)/$(MULTISRCTOP)../libbacktrace \
+ -I$(MULTIBUILDTOP)../libbacktrace \
+ -I../libbacktrace
+
toolexeclib_LTLIBRARIES = libgomp.la
nodist_toolexeclib_HEADERS = libgomp.spec
@@ -70,7 +78,9 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c error.c \
parallel.c sections.c single.c task.c team.c work.c lock.c mutex.c \
proc.c sem.c bar.c ptrlock.c time.c fortran.c affinity.c target.c \
splay-tree.c libgomp-plugin.c oacc-parallel.c oacc-host.c oacc-init.c \
- oacc-mem.c oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c
+ oacc-mem.c oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
+ oacc-profiling.c oacc-profiling-acc_register_library.c \
+ oacc-profiling-locinfo.c
include $(top_srcdir)/plugin/Makefrag.am
@@ -79,7 +89,7 @@ libgomp_la_SOURCES += openacc.f90
endif
nodist_noinst_HEADERS = libgomp_f.h
-nodist_libsubinclude_HEADERS = omp.h openacc.h
+nodist_libsubinclude_HEADERS = acc_prof.h omp.h openacc.h
if USE_FORTRAN
nodist_finclude_HEADERS = omp_lib.h omp_lib.f90 omp_lib.mod omp_lib_kinds.mod \
openacc_lib.h openacc.f90 openacc.mod openacc_kinds.mod
diff --git libgomp/acc_prof.h libgomp/acc_prof.h
new file mode 100644
index 000000000000..7ae0372a3220
--- /dev/null
+++ libgomp/acc_prof.h
@@ -0,0 +1,235 @@
+/* OpenACC Runtime Library: Profiling Interface
+
+ Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+#ifndef _ACC_PROF_H
+#define _ACC_PROF_H 1
+
+/* The OpenACC standard doesn't say so explicitly, but as its Profiling
+ Interface makes use of, for example, <openacc.h>'s acc_device_t, we
+ supposedly are to #include that file here. */
+#include <openacc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.1. Events. */
+
+typedef enum acc_event_t
+{
+ acc_ev_none = 0,
+ acc_ev_device_init_start,
+ acc_ev_device_init_end,
+ acc_ev_device_shutdown_start,
+ acc_ev_device_shutdown_end,
+ acc_ev_runtime_shutdown,
+ acc_ev_create,
+ acc_ev_delete,
+ acc_ev_alloc,
+ acc_ev_free,
+ acc_ev_enter_data_start,
+ acc_ev_enter_data_end,
+ acc_ev_exit_data_start,
+ acc_ev_exit_data_end,
+ acc_ev_update_start,
+ acc_ev_update_end,
+ acc_ev_compute_construct_start,
+ acc_ev_compute_construct_end,
+ acc_ev_enqueue_launch_start,
+ acc_ev_enqueue_launch_end,
+ acc_ev_enqueue_upload_start,
+ acc_ev_enqueue_upload_end,
+ acc_ev_enqueue_download_start,
+ acc_ev_enqueue_download_end,
+ acc_ev_wait_start,
+ acc_ev_wait_end,
+ acc_ev_last
+} acc_event_t;
+
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.2. Callbacks Signature. */
+
+/* 'In all cases, a datatype of "size_t" means a 32-bit integer for a 32-bit
+ binary and a 64-bit integer for a 64-bit binary, and a datatype "int" means
+ a 32-bit integer for both 32-bit and 64-bit binaries'. */
+typedef long int _acc_prof_size_t;
+typedef int _acc_prof_int_t;
+
+/* Internal helpers: a struct's "valid_bytes" may be less than its "sizeof". */
+#define _ACC_PROF_VALID_BYTES_STRUCT(_struct, _lastfield, _valid_bytes_lastfield) \
+ offsetof (_struct, _lastfield) + (_valid_bytes_lastfield)
+#if 0 /* Untested. */
+#define _ACC_PROF_VALID_BYTES_TYPE_N(_type, _n, _valid_bytes_type) \
+ ((_n - 1) * sizeof (_type) + (_valid_bytes_type))
+#endif
+#define _ACC_PROF_VALID_BYTES_BASICTYPE(_basictype) \
+ (sizeof (_basictype))
+
+typedef struct acc_prof_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ _acc_prof_int_t version;
+ acc_device_t device_type;
+ _acc_prof_int_t device_number;
+ _acc_prof_int_t thread_id;
+ _acc_prof_size_t async;
+ _acc_prof_size_t async_queue;
+ const char *src_file;
+ const char *func_name;
+ _acc_prof_int_t line_no, end_line_no;
+ _acc_prof_int_t func_line_no, func_end_line_no;
+#define _ACC_PROF_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_prof_info, func_end_line_no, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_int_t))
+} acc_prof_info;
+
+/* We implement the OpenACC 2.5 Profiling Interface. */
+#define _ACC_PROF_INFO_VERSION 201510
+
+typedef enum acc_construct_t
+{
+ acc_construct_parallel = 0,
+ acc_construct_kernels,
+ acc_construct_loop,
+ acc_construct_data,
+ acc_construct_enter_data,
+ acc_construct_exit_data,
+ acc_construct_host_data,
+ acc_construct_atomic,
+ acc_construct_declare,
+ acc_construct_init,
+ acc_construct_shutdown,
+ acc_construct_set,
+ acc_construct_update,
+ acc_construct_routine,
+ acc_construct_wait,
+ acc_construct_runtime_api
+} acc_construct_t;
+
+typedef struct acc_data_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ const char *var_name;
+ _acc_prof_size_t bytes;
+ void *host_ptr;
+ void *device_ptr;
+#define _ACC_DATA_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_data_event_info, device_ptr, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_data_event_info;
+
+typedef struct acc_launch_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ const char *kernel_name;
+ _acc_prof_size_t num_gangs, num_workers, vector_length;
+#define _ACC_LAUNCH_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_launch_event_info, vector_length, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_size_t))
+} acc_launch_event_info;
+
+typedef struct acc_other_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+#define _ACC_OTHER_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_other_event_info, tool_info, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_other_event_info;
+
+typedef union acc_event_info
+{
+ acc_event_t event_type;
+ acc_data_event_info data_event;
+ acc_launch_event_info launch_event;
+ acc_other_event_info other_event;
+} acc_event_info;
+
+typedef enum acc_device_api
+{
+ acc_device_api_none = 0,
+ acc_device_api_cuda,
+ acc_device_api_opencl,
+ acc_device_api_coi,
+ acc_device_api_other
+} acc_device_api;
+
+typedef struct acc_api_info
+{
+ acc_device_api device_api;
+ _acc_prof_int_t valid_bytes;
+ acc_device_t device_type;
+ _acc_prof_int_t vendor;
+ void *device_handle;
+ void *context_handle;
+ void *async_handle;
+#define _ACC_API_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_api_info, async_handle, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_api_info;
+
+typedef void (*acc_prof_callback) (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.3. Loading the Library. */
+
+typedef enum acc_register_t
+{
+ acc_reg = 0,
+ acc_toggle = 1,
+ acc_toggle_per_thread = 2
+} acc_register_t;
+
+typedef void (*acc_prof_reg) (acc_event_t, acc_prof_callback, acc_register_t);
+extern void acc_prof_register (acc_event_t, acc_prof_callback, acc_register_t) __GOACC_NOTHROW;
+extern void acc_prof_unregister (acc_event_t, acc_prof_callback, acc_register_t) __GOACC_NOTHROW;
+typedef void (*acc_query_fn) ();
+typedef acc_query_fn (*acc_prof_lookup_func) (const char *);
+extern acc_query_fn acc_prof_lookup (const char *) __GOACC_NOTHROW;
+/* Don't tag "acc_register_library" as "__GOACC_NOTHROW": this function can be
+ overridden by the application, and must be expected to do "everything". */
+extern void acc_register_library (acc_prof_reg, acc_prof_reg, acc_prof_lookup_func);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ACC_PROF_H */
diff --git libgomp/env.c libgomp/env.c
index 871a3e4cb40f..c99ba85fc88f 100644
--- libgomp/env.c
+++ libgomp/env.c
@@ -1338,5 +1338,7 @@ initialize_env (void)
parse_acc_device_type ();
goacc_runtime_initialize ();
+
+ goacc_profiling_initialize ();
}
#endif /* LIBGOMP_OFFLOADED_ONLY */
diff --git libgomp/libgomp-plugin.c libgomp/libgomp-plugin.c
index d67b458f714b..7cb123c2a998 100644
--- libgomp/libgomp-plugin.c
+++ libgomp/libgomp-plugin.c
@@ -29,6 +29,7 @@
#include <stdlib.h>
#include "libgomp.h"
+#include "oacc-int.h"
#include "libgomp-plugin.h"
void *
@@ -78,3 +79,11 @@ GOMP_PLUGIN_fatal (const char *msg, ...)
gomp_vfatal (msg, ap);
va_end (ap);
}
+
+void
+GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *prof_info,
+ acc_event_info *event_info,
+ acc_api_info *api_info)
+{
+ goacc_profiling_dispatch (prof_info, event_info, api_info);
+}
diff --git libgomp/libgomp-plugin.h libgomp/libgomp-plugin.h
index 286f7a65d326..42b673b7b43f 100644
--- libgomp/libgomp-plugin.h
+++ libgomp/libgomp-plugin.h
@@ -33,6 +33,8 @@
#include <stddef.h>
#include <stdint.h>
+#include "acc_prof.h"
+
#ifdef __cplusplus
extern "C" {
#endif
@@ -88,6 +90,10 @@ extern void GOMP_PLUGIN_error (const char *, ...)
extern void GOMP_PLUGIN_fatal (const char *, ...)
__attribute__ ((noreturn, format (printf, 1, 2)));
+extern void GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *,
+ acc_event_info *,
+ acc_api_info *);
+
/* Prototypes for functions implemented by libgomp plugins. */
extern const char *GOMP_OFFLOAD_get_name (void);
extern unsigned int GOMP_OFFLOAD_get_caps (void);
diff --git libgomp/libgomp.map libgomp/libgomp.map
index a48393b3771a..78c7f292f6ee 100644
--- libgomp/libgomp.map
+++ libgomp/libgomp.map
@@ -424,6 +424,10 @@ OACC_2.5 {
acc_get_default_async_h_;
acc_memcpy_from_device_async;
acc_memcpy_to_device_async;
+ acc_prof_lookup;
+ acc_prof_register;
+ acc_prof_unregister;
+ acc_register_library;
acc_set_default_async;
acc_set_default_async_h_;
acc_update_device_async;
@@ -482,3 +486,9 @@ GOMP_PLUGIN_1.2 {
global:
GOMP_PLUGIN_acc_thread_default_async;
} GOMP_PLUGIN_1.1;
+
+GOMP_PLUGIN_1.3 {
+ global:
+ GOMP_PLUGIN_goacc_profiling_dispatch;
+ GOMP_PLUGIN_goacc_thread;
+} GOMP_PLUGIN_1.2;
diff --git libgomp/libgomp.texi libgomp/libgomp.texi
index 7a19d382cfc1..5bee6d2f316e 100644
--- libgomp/libgomp.texi
+++ libgomp/libgomp.texi
@@ -111,6 +111,7 @@ changed to GNU Offloading and Multi Processing Runtime Library.
asynchronous operations.
* OpenACC Library Interoperability:: OpenACC library interoperability with the
NVIDIA CUBLAS library.
+* OpenACC Profiling Interface::
* The libgomp ABI:: Notes on the external ABI presented by libgomp.
* Reporting Bugs:: How to report bugs in the GNU Offloading and
Multi Processing Runtime Library.
@@ -2843,13 +2844,15 @@ A.2.1.4.
@node OpenACC Environment Variables
@chapter OpenACC Environment Variables
-The variables @env{ACC_DEVICE_TYPE} and @env{ACC_DEVICE_NUM}
+The variables @env{ACC_DEVICE_TYPE}, @env{ACC_DEVICE_NUM},
+and @code{ACC_PROFLIB}
are defined by section 4 of the OpenACC specification in version 2.5.
The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
@menu
* ACC_DEVICE_TYPE::
* ACC_DEVICE_NUM::
+* ACC_PROFLIB::
* GCC_ACC_NOTIFY::
@end menu
@@ -2875,6 +2878,19 @@ The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
+@node ACC_PROFLIB
+@section @code{ACC_PROFLIB}
+@table @asis
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.5}, section
+4.3.
+@end table
+
+
+
@node GCC_ACC_NOTIFY
@section @code{GCC_ACC_NOTIFY}
@table @asis
@@ -3090,6 +3106,295 @@ Application Programming Interface}, version 2.5.}
+@c ---------------------------------------------------------------------
+@c OpenACC Profiling Interface
+@c ---------------------------------------------------------------------
+
+@node OpenACC Profiling Interface
+@chapter OpenACC Profiling Interface
+
+@section Implementation Status and Implementation-Defined Behavior
+
+We're implementing most of the Profiling Interface as defined by
+the OpenACC 2.5 specification. The specification doesn't
+clearly define some aspects of its Profiling Interface, so we're
+clarifying these as @emph{implementation-defined behavior} here. We
+already have reported to the OpenACC Technical Committee some issues,
+and will report more, later on.
+
+This implementation of the OpenACC Profiling Interface is tuned to
+keep the performance impact as low as possible when it's not in use.
+This is relevant, as the Profiling Interface affects all the
+@emph{hot} code paths (in the target code, not in the offloaded code).
+Users of the OpenACC Profiling Interface can be expected to understand
+that performance will always be impacted to some degree: for example,
+because of the @emph{runtime} (libgomp) calling into a third-party
+@emph{library} for every event that has been registered.
+
+This implementation of the OpenACC Profiling Interface has not yet
+been validated for use in multi-threaded code. This is a more general
+issue; see CSTS-110 @cite{Make sure all OpenACC entry points in
+libgomp are thread-safe}.
+
+The @code{acc_prof_lookup} interface is not implemented, and
+@code{acc_register_library} will receive @code{NULL} for its
+@code{lookup} parameter.
+
+Remarks about data provided to callbacks:
+
+@table @asis
+
+@item @code{acc_prof_info.event_type}
+It is not clear if for @emph{nested} event callbacks (for example,
+@code{acc_ev_enqueue_launch_start} as part of a parent compute
+construct), this should be set for the nested event
+(@code{acc_ev_enqueue_launch_start}), or if the value of the parent
+construct should remain (@code{acc_ev_compute_construct_start}). In
+this implementation, the value will generally correspond to the
+innermost nested event type.
+
+@item @code{acc_prof_info.device_type}
+@itemize
+
+@item
+For @code{acc_ev_compute_construct_start}, and in presence of an
+@code{if} clause with @emph{false} argument, this will still refer to
+the offloading device type; unsure whether that's the expected
+behavior.
+
+@item
+Complementary to the item before, for
+@code{acc_ev_compute_construct_end}, this is set to
+@code{acc_device_host} in presence of an @code{if} clause with
+@emph{false} argument, unsure whether that's the expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.thread_id}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.async}
+@itemize
+
+@item
+Not yet implemented correctly for
+@code{acc_ev_compute_construct_start}.
+
+@item
+In a compute construct, for host-fallback
+execution/@code{acc_device_host} it will always be
+@code{acc_async_sync}; unsure if that is the expected behavior.
+
+@item
+For @code{acc_ev_device_init_start} and @code{acc_ev_device_init_end},
+it will always be @code{acc_async_sync}; unsure if that is the
+expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.async_queue}
+There is no @cite{limited number of asynchronous queues} in libgomp.
+We define this to always have the same value as
+@code{acc_prof_info.async}.
+
+@item @code{acc_prof_info.src_file}, @code{acc_prof_info.func_name}, @code{acc_prof_info.line_no}
+If libbacktrace is available and functional (that is, @code{-g} debug
+information is available), these will be set accordingly for a lot of
+event types. Otherwise, these will be set to @code{NULL}
+(@code{acc_prof_info.src_file}, @code{acc_prof_info.func_name}), or
+@code{-1} (@code{acc_prof_info.line_no}), respectively.
+
+@item @code{acc_prof_info.end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_event_info.event_type}, @code{acc_event_info.*.event_type}
+Relating to @code{acc_prof_info.event_type} discussed above, in this
+implementation, this will always be the same value as
+@code{acc_prof_info.event_type}.
+
+@item @code{acc_event_info.*.parent_construct}
+@itemize
+
+@item
+Will be @code{acc_construct_parallel} for OpenACC kernels constructs;
+should be @code{acc_construct_kernels}.
+
+@item
+Will be @code{acc_construct_enter_data} or
+@code{acc_construct_exit_data} when processing variable mappings
+specified in OpenACC declare directives; should be
+@code{acc_construct_declare}.
+
+@item
+For implicit @code{acc_ev_device_init_start},
+@code{acc_ev_device_init_end}, and explicit as well as implicit
+@code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start},
+@code{acc_ev_enqueue_download_end}, @code{acc_ev_wait_start}, and
+@code{acc_ev_wait_end}, will be
+@code{acc_construct_parallel}; should reflect the real parent
+construct.
+
+@end itemize
+
+@item @code{acc_event_info.*.implicit}
+For @code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start},
+@code{acc_ev_enqueue_download_end}, @code{acc_ev_wait_start}, and
+@code{acc_ev_wait_end}, this currently will be @code{1}
+also for explicit usage.
+
+@item @code{acc_event_info.data_event.var_name}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_event_info.data_event.host_ptr}
+For @code{acc_ev_alloc}, and @code{acc_ev_free}, this is always
+@code{NULL}.
+
+@item @code{typedef union acc_api_info}
+@dots{} as printed in @cite{5.2.3. Third Argument: API-Specific
+Information}, should obviously be @code{typedef @emph{struct}
+acc_api_info}.
+
+@item @code{acc_api_info.device_api}
+Possibly not yet implemented correctly for
+@code{acc_ev_compute_construct_start},
+@code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}:
+will always be @code{acc_device_api_none} for these event types.
+For @code{acc_ev_enter_data_start}, it will be
+@code{acc_device_api_none} in some cases.
+
+@item @code{acc_api_info.device_type}
+Always the same as @code{acc_prof_info.device_type}.
+
+@item @code{acc_api_info.vendor}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_api_info.device_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.context_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.async_handle}
+Always @code{NULL}; not yet implemented.
+
+@end table
+
+Remarks about certain event types:
+
+@table @asis
+
+@item @code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}
+@itemize
+
+@item
+@c See DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT in
+@c libgomp.oacc-c-c++-common/acc_prof-parallel-1.c.
+Whan a compute construct triggers implicit
+@code{acc_ev_device_init_start} and @code{acc_ev_device_init_end}
+events, they currently aren't @emph{nested within} the corresponding
+@code{acc_ev_compute_construct_start} and
+@code{acc_ev_compute_construct_end}, but they're currently observed
+@emph{before} @code{acc_ev_compute_construct_start}. It is not clear
+what to do: the standard asks us provide a lot of details to the
+@code{acc_ev_compute_construct_start} callback, without (implicitly)
+initializing a device before?
+
+@item
+Callbacks for these event types will not be invoked for calls to the
+@code{acc_set_device_type} and @code{acc_set_device_num} functions;
+it's not clear if they should be.
+
+@end itemize
+
+@item @code{acc_ev_enter_data_start}, @code{acc_ev_enter_data_end}, @code{acc_ev_exit_data_start}, @code{acc_ev_exit_data_end}
+@itemize
+
+@item
+Callbacks for these event types will also be invoked for OpenACC
+host_data constructs; it's not clear if they should be.
+
+@item
+Callbacks for these event types will also be invoked when processing
+variable mappings specified in OpenACC declare directives; it's not
+clear if they should be.
+
+@end itemize
+
+@end table
+
+Callbacks for the following event types will be invoked, but dispatch
+and information provided therein has not yet been thoroughly reviewed:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@item @code{acc_ev_update_start}, @code{acc_ev_update_end}
+@item @code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end}
+@item @code{acc_ev_enqueue_download_start}, @code{acc_ev_enqueue_download_end}
+@item @code{acc_ev_wait_start}, @code{acc_ev_wait_end}
+@end itemize
+
+During device initialization, and finalization, respectively,
+callbacks for the following event types will not yet be invoked:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@end itemize
+
+Callbacks for the following event types have not yet been implemented,
+so currently won't be invoked:
+
+@itemize
+@item @code{acc_ev_device_shutdown_start}, @code{acc_ev_device_shutdown_end}
+@item @code{acc_ev_runtime_shutdown}
+@item @code{acc_ev_create}, @code{acc_ev_delete}
+@end itemize
+
+For the following runtime library functions, not all expected
+callbacks will be invoked (mostly concerning implicit device
+initialization):
+
+@itemize
+@item @code{acc_get_num_devices}
+@item @code{acc_set_device_type}
+@item @code{acc_get_device_type}
+@item @code{acc_set_device_num}
+@item @code{acc_get_device_num}
+@item @code{acc_init}
+@item @code{acc_shutdown}
+@end itemize
+
+Aside from implicit device initialization, for the following runtime
+library functions, no callbacks will be invoked for shared-memory
+offloading devices (it's not clear if they should be):
+
+@itemize
+@item @code{acc_malloc}
+@item @code{acc_free}
+@item @code{acc_copyin}, @code{acc_present_or_copyin}, @code{acc_copyin_async}
+@item @code{acc_create}, @code{acc_present_or_create}, @code{acc_create_async}
+@item @code{acc_copyout}, @code{acc_copyout_async}, @code{acc_copyout_finalize}, @code{acc_copyout_finalize_async}
+@item @code{acc_delete}, @code{acc_delete_async}, @code{acc_delete_finalize}, @code{acc_delete_finalize_async}
+@item @code{acc_update_device}, @code{acc_update_device_async}
+@item @code{acc_update_self}, @code{acc_update_self_async}
+@item @code{acc_map_data}, @code{acc_unmap_data}
+@item @code{acc_memcpy_to_device}, @code{acc_memcpy_to_device_async}
+@item @code{acc_memcpy_from_device}, @code{acc_memcpy_from_device_async}
+@end itemize
+
+
+
@c ---------------------------------------------------------------------
@c The libgomp ABI
@c ---------------------------------------------------------------------
diff --git libgomp/oacc-async.c libgomp/oacc-async.c
index 6ef7115fa355..f651ee15a3c0 100644
--- libgomp/oacc-async.c
+++ libgomp/oacc-async.c
@@ -117,9 +117,26 @@ acc_async_test (int async)
if (!thr || !thr->dev)
gomp_fatal ("no device active");
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq = lookup_goacc_asyncqueue (thr, true, async);
int res = thr->dev->openacc.async.test_func (aq);
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return res;
}
@@ -130,6 +147,12 @@ acc_async_test_all (void)
if (!thr || !thr->dev)
gomp_fatal ("no device active");
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+
int ret = 1;
gomp_mutex_lock (&thr->dev->openacc.async.lock);
for (goacc_aq_list l = thr->dev->openacc.async.active; l; l = l->next)
@@ -140,6 +163,11 @@ acc_async_test_all (void)
}
gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
return ret;
}
@@ -151,11 +179,28 @@ acc_wait (int async)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
if (!thr || !thr->dev)
gomp_fatal ("no device active");
goacc_aq aq = lookup_goacc_asyncqueue (thr, true, async);
thr->dev->openacc.async.synchronize_func (aq);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
/* acc_async_wait is an OpenACC 1.0 compatibility name for acc_wait. */
@@ -174,6 +219,17 @@ acc_wait_async (int async1, int async2)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async2;
+ prof_info.async_queue = prof_info.async;
+ }
+
if (!thr || !thr->dev)
gomp_fatal ("no device active");
@@ -186,6 +242,12 @@ acc_wait_async (int async1, int async2)
thr->dev->openacc.async.synchronize_func (aq1);
thr->dev->openacc.async.serialize_func (aq1, aq2);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -193,6 +255,12 @@ acc_wait_all (void)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+
if (!thr || !thr->dev)
gomp_fatal ("no device active");
@@ -202,6 +270,12 @@ acc_wait_all (void)
for (goacc_aq_list l = dev->openacc.async.active; l; l = l->next)
dev->openacc.async.synchronize_func (l->aq);
gomp_mutex_unlock (&dev->openacc.async.lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
/* acc_async_wait_all is an OpenACC 1.0 compatibility name for acc_wait_all. */
@@ -223,6 +297,17 @@ acc_wait_all_async (int async)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
if (!thr || !thr->dev)
gomp_fatal ("no device active");
@@ -236,11 +321,20 @@ acc_wait_all_async (int async)
thr->dev->openacc.async.serialize_func (l->aq, waiting_queue);
}
gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
int
acc_get_default_async (void)
{
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
struct goacc_thread *thr = goacc_thread ();
if (!thr || !thr->dev)
@@ -252,6 +346,9 @@ acc_get_default_async (void)
void
acc_set_default_async (int async)
{
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
if (async < acc_async_sync)
gomp_fatal ("invalid async argument: %d", async);
diff --git libgomp/oacc-cuda.c libgomp/oacc-cuda.c
index cde51b768a10..7e902894c591 100644
--- libgomp/oacc-cuda.c
+++ libgomp/oacc-cuda.c
@@ -36,10 +36,23 @@ acc_get_current_cuda_device (void)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_device_func)
- return thr->dev->openacc.cuda.get_current_device_func ();
+ ret = thr->dev->openacc.cuda.get_current_device_func ();
- return NULL;
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return ret;
}
void *
@@ -47,10 +60,23 @@ acc_get_current_cuda_context (void)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_context_func)
- return thr->dev->openacc.cuda.get_current_context_func ();
-
- return NULL;
+ ret = thr->dev->openacc.cuda.get_current_context_func ();
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return ret;
}
void *
@@ -61,6 +87,17 @@ acc_get_cuda_stream (int async)
if (async < 0)
return NULL;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_stream_func)
{
@@ -69,6 +106,12 @@ acc_get_cuda_stream (int async)
ret = thr->dev->openacc.cuda.get_stream_func (aq);
}
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return ret;
}
@@ -80,10 +123,21 @@ acc_set_cuda_stream (int async, void *stream)
if (async < 0 || stream == NULL)
return 0;
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (1);
thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
int ret = -1;
if (thr && thr->dev && thr->dev->openacc.cuda.set_stream_func)
{
@@ -93,5 +147,11 @@ acc_set_cuda_stream (int async, void *stream)
gomp_mutex_unlock (&thr->dev->openacc.async.lock);
}
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return ret;
}
diff --git libgomp/oacc-init.c libgomp/oacc-init.c
index c09ba35a6fe5..05559accb0db 100644
--- libgomp/oacc-init.c
+++ libgomp/oacc-init.c
@@ -230,13 +230,68 @@ acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)
held before calling this function. */
static struct gomp_device_descr *
-acc_init_1 (acc_device_t d)
+acc_init_1 (struct goacc_thread *thr, acc_device_t d,
+ acc_construct_t parent_construct, int implicit,
+ int acc_prof_locinfo_skip)
{
gomp_mutex_lock (&acc_init_state_lock);
acc_init_state = initializing;
acc_init_thread = pthread_self ();
gomp_mutex_unlock (&acc_init_state_lock);
+ bool check_not_nested_p;
+ if (implicit)
+ {
+ /* In the implicit case, there should (must?) already be something
+ have been set up for an outer construct. */
+ check_not_nested_p = false;
+ }
+ else
+ {
+ check_not_nested_p = true;
+ }
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (check_not_nested_p),
+ false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_device_init_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = d;
+ prof_info.device_number = goacc_device_num;
+ prof_info.thread_id = -1;
+ prof_info.async = acc_async_sync;
+ prof_info.async_queue = prof_info.async;
+ goacc_profiling_locinfo_fill (thr, &prof_info, acc_prof_locinfo_skip + 1);
+ }
+ acc_event_info device_init_event_info;
+ if (profiling_dispatch_p)
+ {
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ device_init_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ device_init_event_info.other_event.parent_construct = parent_construct;
+ device_init_event_info.other_event.implicit = implicit;
+ device_init_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info, &api_info);
+
struct gomp_device_descr *base_dev, *acc_dev;
int ndevs;
@@ -259,6 +314,14 @@ acc_init_1 (acc_device_t d)
gomp_init_device (acc_dev);
gomp_mutex_unlock (&acc_dev->lock);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_device_init_end;
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info,
+ &api_info);
+ }
+
gomp_mutex_lock (&acc_init_state_lock);
acc_init_state = initialized;
gomp_mutex_unlock (&acc_init_state_lock);
@@ -454,7 +517,12 @@ goacc_attach_host_thread_to_device (int ord)
thr->dev = acc_dev = &base_dev[ord];
thr->saved_bound_dev = NULL;
thr->mapped_data = NULL;
-
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ /* Initially, all callbacks for all events are enabled. */
+ thr->prof_callbacks_enabled = true;
+ thr->backtrace_state = NULL;
+
thr->target_tls
= acc_dev->openacc.create_thread_data_func (ord);
@@ -470,9 +538,7 @@ acc_init (acc_device_t d)
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
-
- cached_base_dev = acc_init_1 (d);
-
+ cached_base_dev = acc_init_1 (NULL, d, acc_construct_runtime_api, 0, 1);
gomp_mutex_unlock (&acc_device_lock);
goacc_attach_host_thread_to_device (-1);
@@ -531,6 +597,14 @@ acc_set_device_type (acc_device_t d)
struct gomp_device_descr *base_dev, *acc_dev;
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+ if (profiling_setup_p)
+ prof_info.device_type = d;
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
@@ -555,6 +629,12 @@ acc_set_device_type (acc_device_t d)
}
goacc_attach_host_thread_to_device (-1);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
ialias (acc_set_device_type)
@@ -590,12 +670,24 @@ acc_get_device_type (void)
;
else
{
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (acc_device_default, true);
gomp_mutex_unlock (&acc_device_lock);
res = acc_device_type (dev->type);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
assert (res != acc_device_default
@@ -612,6 +704,14 @@ acc_get_device_num (acc_device_t d)
const struct gomp_device_descr *dev;
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+ if (profiling_setup_p)
+ prof_info.device_type = d;
+
if (d >= _ACC_device_hwm)
gomp_fatal ("unknown device type %u", (unsigned) d);
@@ -621,6 +721,12 @@ acc_get_device_num (acc_device_t d)
dev = resolve_device (d, true);
gomp_mutex_unlock (&acc_device_lock);
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
if (thr && thr->base_dev == dev && thr->dev)
return thr->dev->target_id;
@@ -735,15 +841,20 @@ goacc_restore_bind (void)
On exit "goacc_thread" will return a valid & populated thread block. */
attribute_hidden void
-goacc_lazy_initialize (void)
+goacc_lazy_initialize (int acc_prof_locinfo_skip)
{
struct goacc_thread *thr = goacc_thread ();
-
if (thr && thr->dev)
return;
+ gomp_init_targets_once ();
+
+ gomp_mutex_lock (&acc_device_lock);
if (!cached_base_dev)
- acc_init (acc_device_default);
- else
- goacc_attach_host_thread_to_device (-1);
+ cached_base_dev = acc_init_1 (thr, acc_device_default,
+ acc_construct_parallel, 1,
+ acc_prof_locinfo_skip + 1);
+ gomp_mutex_unlock (&acc_device_lock);
+
+ goacc_attach_host_thread_to_device (-1);
}
diff --git libgomp/oacc-int.h libgomp/oacc-int.h
index ecc905214ac4..780bec03d156 100644
--- libgomp/oacc-int.h
+++ libgomp/oacc-int.h
@@ -40,6 +40,8 @@
#include "openacc.h"
#include "config.h"
+#include "acc_prof.h"
+#include "backtrace.h"
#include <stddef.h>
#include <stdbool.h>
#include <stdarg.h>
@@ -68,6 +70,14 @@ struct goacc_thread
strictly push/pop semantics according to lexical scope. */
struct target_mem_desc *mapped_data;
+ /* Data of the OpenACC Profiling Interface. */
+ acc_prof_info *prof_info;
+ acc_api_info *api_info;
+ /* Per-thread toggle of OpenACC Profiling Interface callbacks. */
+ bool prof_callbacks_enabled;
+ /* Per-thread state of libbacktrace. */
+ struct backtrace_state *backtrace_state;
+
/* These structures form a list: this is the next thread in that list. */
struct goacc_thread *next;
@@ -99,7 +109,7 @@ void goacc_attach_host_thread_to_device (int);
void goacc_runtime_initialize (void);
void goacc_save_and_set_bind (acc_device_t);
void goacc_restore_bind (void);
-void goacc_lazy_initialize (void);
+void goacc_lazy_initialize (int);
void goacc_host_init (void);
void goacc_init_asyncqueues (struct gomp_device_descr *);
@@ -111,6 +121,16 @@ void goacc_async_free (struct gomp_device_descr *,
struct goacc_asyncqueue *get_goacc_asyncqueue (int);
struct goacc_asyncqueue *lookup_goacc_asyncqueue (struct goacc_thread *, bool, int);
+void goacc_profiling_initialize (void);
+bool goacc_profiling_setup_p (struct goacc_thread *,
+ acc_prof_info *, acc_api_info *, int);
+bool goacc_profiling_dispatch_p (bool);
+void goacc_profiling_dispatch (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+void goacc_profiling_locinfo_initialize ();
+void goacc_profiling_locinfo_fill (struct goacc_thread *,
+ acc_prof_info *, int);
+
#ifdef HAVE_ATTRIBUTE_VISIBILITY
# pragma GCC visibility pop
#endif
diff --git libgomp/oacc-mem.c libgomp/oacc-mem.c
index 0e39aff84343..20b9c2090f84 100644
--- libgomp/oacc-mem.c
+++ libgomp/oacc-mem.c
@@ -99,16 +99,31 @@ acc_malloc (size_t s)
if (!s)
return NULL;
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (1);
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+
assert (thr->dev);
+ void *ret;
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- return malloc (s);
+ ret = malloc (s);
+ else
+ ret = thr->dev->alloc_func (thr->dev->target_id, s);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
- return thr->dev->alloc_func (thr->dev->target_id, s);
+ return ret;
}
/* OpenACC 2.0a (3.2.16) doesn't specify what to do in the event
@@ -124,12 +139,22 @@ acc_free (void *d)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+
assert (thr && thr->dev);
struct gomp_device_descr *acc_dev = thr->dev;
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- return free (d);
+ {
+ free (d);
+
+ goto out;
+ }
gomp_mutex_lock (&acc_dev->lock);
@@ -151,16 +176,35 @@ acc_free (void *d)
if (!acc_dev->free_func (acc_dev->target_id, d))
gomp_fatal ("error in freeing device memory in %s", __FUNCTION__);
+
+ out:
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
memcpy_tofrom_device (bool from, void *d, void *h, size_t s, int async,
- const char *libfnname)
+ const char *libfnname, int acc_prof_locinfo_skip)
{
/* No need to call lazy open here, as the device pointer must have
been obtained from a routine that did that. */
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info,
+ acc_prof_locinfo_skip + 1),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
assert (thr && thr->dev);
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
@@ -169,7 +213,8 @@ memcpy_tofrom_device (bool from, void *d, void *h, size_t s, int async,
memmove (h, d, s);
else
memmove (d, h, s);
- return;
+
+ goto out;
}
goacc_aq aq = get_goacc_asyncqueue (async);
@@ -177,30 +222,37 @@ memcpy_tofrom_device (bool from, void *d, void *h, size_t s, int async,
gomp_copy_dev2host (thr->dev, aq, h, d, s);
else
gomp_copy_host2dev (thr->dev, aq, d, h, s, /* TODO: cbuf? */ NULL);
+
+ out:
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
acc_memcpy_to_device (void *d, void *h, size_t s)
{
- memcpy_tofrom_device (false, d, h, s, acc_async_sync, __FUNCTION__);
+ memcpy_tofrom_device (false, d, h, s, acc_async_sync, __FUNCTION__, 1);
}
void
acc_memcpy_to_device_async (void *d, void *h, size_t s, int async)
{
- memcpy_tofrom_device (false, d, h, s, async, __FUNCTION__);
+ memcpy_tofrom_device (false, d, h, s, async, __FUNCTION__, 1);
}
void
acc_memcpy_from_device (void *h, void *d, size_t s)
{
- memcpy_tofrom_device (true, d, h, s, acc_async_sync, __FUNCTION__);
+ memcpy_tofrom_device (true, d, h, s, acc_async_sync, __FUNCTION__, 1);
}
void
acc_memcpy_from_device_async (void *h, void *d, size_t s, int async)
{
- memcpy_tofrom_device (true, d, h, s, async, __FUNCTION__);
+ memcpy_tofrom_device (true, d, h, s, async, __FUNCTION__, 1);
}
/* Return the device pointer that corresponds to host data H. Or NULL
@@ -213,7 +265,7 @@ acc_deviceptr (void *h)
void *d;
void *offset;
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (1);
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *dev = thr->dev;
@@ -221,6 +273,9 @@ acc_deviceptr (void *h)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&dev->lock);
n = lookup_host (dev, h, 1);
@@ -250,7 +305,7 @@ acc_hostptr (void *d)
void *h;
void *offset;
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (1);
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
@@ -258,6 +313,9 @@ acc_hostptr (void *d)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return d;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_dev (acc_dev->openacc.data_environ, d, 1);
@@ -287,7 +345,7 @@ acc_is_present (void *h, size_t s)
if (!s || !h)
return 0;
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (1);
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
@@ -295,6 +353,9 @@ acc_is_present (void *h, size_t s)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h != NULL;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -321,11 +382,17 @@ acc_map_data (void *h, void *d, size_t s)
size_t sizes = s;
unsigned short kinds = GOMP_MAP_ALLOC;
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (1);
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
{
if (d != h)
@@ -366,6 +433,12 @@ acc_map_data (void *h, void *d, size_t s)
tgt->prev = acc_dev->openacc.data_environ;
acc_dev->openacc.data_environ = tgt;
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -380,6 +453,12 @@ acc_unmap_data (void *h)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+
size_t host_size;
gomp_mutex_lock (&acc_dev->lock);
@@ -433,6 +512,12 @@ acc_unmap_data (void *h)
gomp_mutex_unlock (&acc_dev->lock);
gomp_unmap_vars (t, true);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
#define FLAG_PRESENT (1 << 0)
@@ -440,7 +525,8 @@ acc_unmap_data (void *h)
#define FLAG_COPY (1 << 2)
static void *
-present_create_copy (unsigned f, void *h, size_t s, int async)
+present_create_copy (unsigned f, void *h, size_t s, int async,
+ int acc_prof_locinfo_skip)
{
void *d;
splay_tree_key n;
@@ -448,7 +534,7 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
if (!h || !s)
gomp_fatal ("[%p,+%d] is a bad range", (void *)h, (int)s);
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (1);
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
@@ -456,6 +542,18 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info,
+ acc_prof_locinfo_skip + 1),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -518,19 +616,26 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
gomp_mutex_unlock (&acc_dev->lock);
}
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return d;
}
void *
acc_create (void *h, size_t s)
{
- return present_create_copy (FLAG_PRESENT | FLAG_CREATE, h, s, acc_async_sync);
+ return present_create_copy (FLAG_PRESENT | FLAG_CREATE, h, s, acc_async_sync,
+ 1);
}
void
acc_create_async (void *h, size_t s, int async)
{
- present_create_copy (FLAG_PRESENT | FLAG_CREATE, h, s, async);
+ present_create_copy (FLAG_PRESENT | FLAG_CREATE, h, s, async, 1);
}
/* acc_present_or_create used to be what acc_create is now. */
@@ -556,13 +661,13 @@ void *
acc_copyin (void *h, size_t s)
{
return present_create_copy (FLAG_PRESENT | FLAG_CREATE | FLAG_COPY, h, s,
- acc_async_sync);
+ acc_async_sync, 1);
}
void
acc_copyin_async (void *h, size_t s, int async)
{
- present_create_copy (FLAG_PRESENT | FLAG_CREATE | FLAG_COPY, h, s, async);
+ present_create_copy (FLAG_PRESENT | FLAG_CREATE | FLAG_COPY, h, s, async, 1);
}
/* acc_present_or_copyin used to be what acc_copyin is now. */
@@ -588,7 +693,8 @@ acc_pcopyin (void *h, size_t s)
#define FLAG_FINALIZE (1 << 1)
static void
-delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
+delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname,
+ int acc_prof_locinfo_skip)
{
size_t host_size;
splay_tree_key n;
@@ -599,6 +705,18 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info,
+ acc_prof_locinfo_skip + 1),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -672,64 +790,71 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
}
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
acc_delete (void *h , size_t s)
{
- delete_copyout (0, h, s, acc_async_sync, __FUNCTION__);
+ delete_copyout (0, h, s, acc_async_sync, __FUNCTION__, 1);
}
void
acc_delete_async (void *h , size_t s, int async)
{
- delete_copyout (0, h, s, async, __FUNCTION__);
+ delete_copyout (0, h, s, async, __FUNCTION__, 1);
}
void
acc_delete_finalize (void *h , size_t s)
{
- delete_copyout (FLAG_FINALIZE, h, s, acc_async_sync, __FUNCTION__);
+ delete_copyout (FLAG_FINALIZE, h, s, acc_async_sync, __FUNCTION__, 1);
}
void
acc_delete_finalize_async (void *h , size_t s, int async)
{
- delete_copyout (FLAG_FINALIZE, h, s, async, __FUNCTION__);
+ delete_copyout (FLAG_FINALIZE, h, s, async, __FUNCTION__, 1);
}
void
acc_copyout (void *h, size_t s)
{
- delete_copyout (FLAG_COPYOUT, h, s, acc_async_sync, __FUNCTION__);
+ delete_copyout (FLAG_COPYOUT, h, s, acc_async_sync, __FUNCTION__, 1);
}
void
acc_copyout_async (void *h, size_t s, int async)
{
- delete_copyout (FLAG_COPYOUT, h, s, async, __FUNCTION__);
+ delete_copyout (FLAG_COPYOUT, h, s, async, __FUNCTION__, 1);
}
void
acc_copyout_finalize (void *h, size_t s)
{
delete_copyout (FLAG_COPYOUT | FLAG_FINALIZE, h, s, acc_async_sync,
- __FUNCTION__);
+ __FUNCTION__, 1);
}
void
acc_copyout_finalize_async (void *h, size_t s, int async)
{
- delete_copyout (FLAG_COPYOUT | FLAG_FINALIZE, h, s, async, __FUNCTION__);
+ delete_copyout (FLAG_COPYOUT | FLAG_FINALIZE, h, s, async, __FUNCTION__, 1);
}
static void
-update_dev_host (int is_dev, void *h, size_t s, int async)
+update_dev_host (int is_dev, void *h, size_t s, int async,
+ int acc_prof_locinfo_skip)
{
splay_tree_key n;
void *d;
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (acc_prof_locinfo_skip + 1);
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
@@ -739,6 +864,18 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
gomp_mutex_lock (&acc_dev->lock);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info,
+ acc_prof_locinfo_skip + 1),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
n = lookup_host (acc_dev, h, s);
if (!n)
@@ -758,30 +895,36 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
gomp_copy_dev2host (acc_dev, aq, h, d, s);
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
acc_update_device (void *h, size_t s)
{
- update_dev_host (1, h, s, acc_async_sync);
+ update_dev_host (1, h, s, acc_async_sync, 1);
}
void
acc_update_device_async (void *h, size_t s, int async)
{
- update_dev_host (1, h, s, async);
+ update_dev_host (1, h, s, async, 1);
}
void
acc_update_self (void *h, size_t s)
{
- update_dev_host (0, h, s, acc_async_sync);
+ update_dev_host (0, h, s, acc_async_sync, 1);
}
void
acc_update_self_async (void *h, size_t s, int async)
{
- update_dev_host (0, h, s, async);
+ update_dev_host (0, h, s, async, 1);
}
void
diff --git libgomp/oacc-parallel.c libgomp/oacc-parallel.c
index 6a7d068300e4..28ed9c367b19 100644
--- libgomp/oacc-parallel.c
+++ libgomp/oacc-parallel.c
@@ -145,7 +145,8 @@ goacc_call_host_fn (void (*fn) (void *), size_t mapnum, void **hostaddrs,
static void
GOACC_parallel_keyed_internal (int device, int params, void (*fn) (void *),
size_t mapnum, void **hostaddrs, size_t *sizes,
- unsigned short *kinds, va_list *ap)
+ unsigned short *kinds, va_list *ap,
+ int acc_prof_locinfo_skip)
{
bool host_fallback = device == GOMP_DEVICE_HOST_FALLBACK;
struct goacc_thread *thr;
@@ -167,27 +168,79 @@ GOACC_parallel_keyed_internal (int device, int params, void (*fn) (void *),
gomp_debug (0, "%s: mapnum=%lu, hostaddrs=%p, sizes=%p, kinds=%p\n",
__FUNCTION__, (unsigned long) mapnum, hostaddrs, sizes, kinds);
#endif
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (acc_prof_locinfo_skip + 1);
thr = goacc_thread ();
acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_compute_construct_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ goacc_profiling_locinfo_fill (thr, &prof_info, acc_prof_locinfo_skip + 1);
+ }
+ acc_event_info compute_construct_event_info;
+ if (profiling_dispatch_p)
+ {
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ compute_construct_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ compute_construct_event_info.other_event.parent_construct
+ = acc_construct_parallel;
+ compute_construct_event_info.other_event.implicit = 0;
+ compute_construct_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds);
/* Host fallback if "if" clause is false or if the current device is set to
the host. */
if (host_fallback)
{
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
goacc_save_and_set_bind (acc_device_host);
goacc_call_host_fn (fn, mapnum, hostaddrs, params);
goacc_restore_bind ();
- return;
+ goto out;
}
else if (acc_device_type (acc_dev->type) == acc_device_host)
{
goacc_call_host_fn (fn, mapnum, hostaddrs, params);
- return;
+ goto out;
}
+ else if (profiling_dispatch_p)
+ api_info.device_api = acc_device_api_cuda;
/* Default: let the runtime choose. */
for (i = 0; i != GOMP_DIM_MAX; i++)
@@ -219,6 +272,13 @@ GOACC_parallel_keyed_internal (int device, int params, void (*fn) (void *),
if (async == GOMP_LAUNCH_OP_MAX)
async = va_arg (*ap, unsigned);
+
+ if (profiling_dispatch_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
break;
}
@@ -257,10 +317,34 @@ GOACC_parallel_keyed_internal (int device, int params, void (*fn) (void *),
else
tgt_fn = (void (*)) fn;
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_start;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = compute_construct_event_info.other_event.parent_construct;
+ enter_exit_data_event_info.other_event.implicit = 1;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
+
goacc_aq aq = get_goacc_asyncqueue (async);
tgt = gomp_map_vars_async (acc_dev, aq, mapnum, hostaddrs, NULL, sizes, kinds,
true, GOMP_MAP_VARS_OPENACC);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
devaddrs = gomp_alloca (sizeof (void *) * mapnum);
for (i = 0; i < mapnum; i++)
@@ -281,8 +365,25 @@ GOACC_parallel_keyed_internal (int device, int params, void (*fn) (void *),
else
acc_dev->openacc.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs,
dims, tgt);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_start;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
/* If running synchronously, unmap immediately. */
gomp_unmap_vars (tgt, true);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
}
else
{
@@ -294,6 +395,19 @@ GOACC_parallel_keyed_internal (int device, int params, void (*fn) (void *),
devaddrs, dims, tgt, aq);
goacc_async_copyout_unmap_vars (tgt, aq);
}
+
+ out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_compute_construct_end;
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -304,7 +418,7 @@ GOACC_parallel_keyed (int device, void (*fn) (void *),
va_list ap;
va_start (ap, kinds);
GOACC_parallel_keyed_internal (device, 0, fn, mapnum, hostaddrs, sizes,
- kinds, &ap);
+ kinds, &ap, 1);
va_end (ap);
}
@@ -316,7 +430,7 @@ GOACC_parallel_keyed_v2 (int device, int args, void (*fn) (void *),
va_list ap;
va_start (ap, kinds);
GOACC_parallel_keyed_internal (device, args, fn, mapnum, hostaddrs, sizes,
- kinds, &ap);
+ kinds, &ap, 1);
va_end (ap);
}
@@ -349,23 +463,84 @@ GOACC_data_start (int device, size_t mapnum,
__FUNCTION__, (unsigned long) mapnum, hostaddrs, sizes, kinds);
#endif
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (1);
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_enter_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ prof_info.async_queue = prof_info.async;
+ goacc_profiling_locinfo_fill (thr, &prof_info, 1);
+ }
+ acc_event_info enter_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ enter_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_data_event_info.other_event.parent_construct = acc_construct_data;
+ for (int i = 0; i < mapnum; ++i)
+ if (kinds[i] == GOMP_MAP_USE_DEVICE_PTR)
+ {
+ /* If there is one such data mapping kind, then this is actually an
+ OpenACC host_data construct. (GCC maps the OpenACC host_data
+ construct to the OpenACC data construct.) Apart from artificial
+ test cases (such as an OpenACC host_data construct's (implicit)
+ device initialization when there hasn't been any device data be
+ set up before...), there can't really any meaningful events be
+ generated from OpenACC host_data constructs, though. */
+ enter_data_event_info.other_event.parent_construct
+ = acc_construct_host_data;
+ break;
+ }
+ enter_data_event_info.other_event.implicit = 0;
+ enter_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds);
/* Host fallback or 'do nothing'. */
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| host_fallback)
{
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
tgt = gomp_map_vars (NULL, 0, NULL, NULL, NULL, NULL, true,
GOMP_MAP_VARS_OPENACC);
tgt->prev = thr->mapped_data;
thr->mapped_data = tgt;
-
- return;
+ goto out;
}
gomp_debug (0, " %s: prepare mappings\n", __FUNCTION__);
@@ -374,18 +549,86 @@ GOACC_data_start (int device, size_t mapnum,
gomp_debug (0, " %s: mappings prepared\n", __FUNCTION__);
tgt->prev = thr->mapped_data;
thr->mapped_data = tgt;
+
+ out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_data_end (void)
{
struct goacc_thread *thr = goacc_thread ();
+ struct gomp_device_descr *acc_dev = thr->dev;
struct target_mem_desc *tgt = thr->mapped_data;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ prof_info.async_queue = prof_info.async;
+ goacc_profiling_locinfo_fill (thr, &prof_info, 1);
+ }
+ acc_event_info exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ exit_data_event_info.other_event.parent_construct = acc_construct_data;
+ exit_data_event_info.other_event.implicit = 0;
+ exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
gomp_debug (0, " %s: restore mappings\n", __FUNCTION__);
thr->mapped_data = tgt->prev;
gomp_unmap_vars (tgt, true);
gomp_debug (0, " %s: mappings restored\n", __FUNCTION__);
+
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_end;
+ exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -393,6 +636,9 @@ GOACC_enter_exit_data (int device, size_t mapnum,
void **hostaddrs, size_t *sizes, unsigned short *kinds,
int async, int num_waits, ...)
{
+ struct goacc_thread *thr;
+ struct gomp_device_descr *acc_dev;
+ bool host_fallback = device == GOMP_DEVICE_HOST_FALLBACK;
bool data_enter = false;
size_t i;
@@ -437,7 +683,67 @@ GOACC_enter_exit_data (int device, size_t mapnum,
kind);
}
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (1);
+
+ thr = goacc_thread ();
+ acc_dev = thr->dev;
+
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type
+ = data_enter ? acc_ev_enter_data_start : acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ goacc_profiling_locinfo_fill (thr, &prof_info, 1);
+ }
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = data_enter ? acc_construct_enter_data : acc_construct_exit_data;
+ enter_exit_data_event_info.other_event.implicit = 0;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
+ || host_fallback)
+ {
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+ goto out;
+ }
if (num_waits > 0)
{
@@ -558,6 +864,18 @@ GOACC_enter_exit_data (int device, size_t mapnum,
i += pointer - 1;
}
}
+
+ out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = data_enter ? acc_ev_enter_data_end: acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
@@ -596,14 +914,64 @@ GOACC_update (int device, size_t mapnum,
bool host_fallback = device == GOMP_DEVICE_HOST_FALLBACK;
size_t i;
- goacc_lazy_initialize ();
+ goacc_lazy_initialize (1);
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_update_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ goacc_profiling_locinfo_fill (thr, &prof_info, 1);
+ }
+ acc_event_info update_event_info;
+ if (profiling_dispatch_p)
+ {
+ update_event_info.other_event.event_type
+ = prof_info.event_type;
+ update_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ update_event_info.other_event.parent_construct = acc_construct_update;
+ update_event_info.other_event.implicit = 0;
+ update_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| host_fallback)
- return;
+ {
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+ goto out;
+ }
if (num_waits > 0)
{
@@ -675,11 +1043,40 @@ GOACC_update (int device, size_t mapnum,
break;
}
}
+
+ out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_update_end;
+ update_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_wait (int async, int num_waits, ...)
{
+ goacc_lazy_initialize (1);
+
+ struct goacc_thread *thr = goacc_thread ();
+
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info, 1),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
if (num_waits)
{
va_list ap;
@@ -692,6 +1089,12 @@ GOACC_wait (int async, int num_waits, ...)
acc_wait_all ();
else if (async == acc_async_noval)
acc_wait_all_async (async);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
int
diff --git libgomp/oacc-plugin.c libgomp/oacc-plugin.c
index a7eecdc3bbc7..10a1169dc486 100644
--- libgomp/oacc-plugin.c
+++ libgomp/oacc-plugin.c
@@ -39,6 +39,19 @@ GOMP_PLUGIN_acc_thread (void)
return thr ? thr->target_tls : NULL;
}
+/* Return the TLS data for the current thread. */
+/* TODO. Should we be able to directly call (the static inline function)
+ goacc_thread from within plugin code? I didn't manage to get the
+ "goacc_tls_data" symbol configured correctly: "[...]/ld:
+ .libs/libgomp-plugin-nvptx.so.1.0.0: hidden symbol `goacc_tls_data' isn't
+ defined". */
+
+struct goacc_thread *
+GOMP_PLUGIN_goacc_thread (void)
+{
+ return goacc_thread ();
+}
+
/* Return the default async number from the TLS data for the current thread. */
int
diff --git libgomp/oacc-plugin.h libgomp/oacc-plugin.h
index adf04d62b4af..52949ca704b0 100644
--- libgomp/oacc-plugin.h
+++ libgomp/oacc-plugin.h
@@ -27,8 +27,11 @@
#ifndef OACC_PLUGIN_H
#define OACC_PLUGIN_H 1
+#include "oacc-int.h"
+
extern void GOMP_PLUGIN_async_unmap_vars (void *, int);
extern void *GOMP_PLUGIN_acc_thread (void);
+extern struct goacc_thread *GOMP_PLUGIN_goacc_thread (void);
extern int GOMP_PLUGIN_acc_thread_default_async (void);
#endif
diff --git libgomp/oacc-profiling-acc_register_library.c libgomp/oacc-profiling-acc_register_library.c
new file mode 100644
index 000000000000..f6b482b51f4b
--- /dev/null
+++ libgomp/oacc-profiling-acc_register_library.c
@@ -0,0 +1,39 @@
+/* Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+/* This file provides an stub acc_register_library function. It's in a
+ separate file so that this function can easily be overridden when linking
+ statically. */
+
+#include "libgomp.h"
+#include "acc_prof.h"
+
+void
+acc_register_library (acc_prof_reg reg, acc_prof_reg unreg,
+ acc_prof_lookup_func lookup)
+{
+ gomp_debug (0, "dummy %s\n", __FUNCTION__);
+}
diff --git libgomp/oacc-profiling-locinfo.c libgomp/oacc-profiling-locinfo.c
new file mode 100644
index 000000000000..c139fd70b6f7
--- /dev/null
+++ libgomp/oacc-profiling-locinfo.c
@@ -0,0 +1,138 @@
+/* Copyright (C) 2018 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+/* OpenACC Profiling Interface: location information. */
+
+#include "libgomp.h"
+#include "oacc-int.h"
+#include "backtrace-supported.h"
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+
+
+/* Initialize. */
+void
+goacc_profiling_locinfo_initialize ()
+{
+ if (!BACKTRACE_SUPPORTED)
+ gomp_debug (0, "libbacktrace not supported:"
+ " can't provide location information in"
+ " the OpenACC Profiling Interface\n");
+}
+
+/* Initialize for "thr" if not yet done. */
+static void
+goacc_profiling_locinfo_initialize_thr (struct goacc_thread *thr)
+{
+ if (__builtin_expect (thr->backtrace_state == NULL, false))
+ {
+ /* Separate state per thread, to avoid locking. */
+ thr->backtrace_state = backtrace_create_state (NULL, 0, NULL, NULL);
+ if (thr->backtrace_state == NULL)
+ gomp_fatal ("failed to create state information for libbacktrace");
+ }
+}
+
+static void
+error_callback (void *data, const char *msg, int errnum)
+{
+ if (errnum < 0)
+ gomp_debug (0, "could not generate backtrace: %s\n", msg);
+ else if (errnum == 0)
+ gomp_debug (0, "could not generate backtrace: %s\n", msg);
+ else
+ gomp_debug (0, "could not generate backtrace: %s: %s\n", msg, strerror (errnum));
+}
+
+static int
+full_callback (void *data, uintptr_t pc, const char *filename, int lineno, const char *function)
+{
+ gomp_debug (0, " libbacktrace found for PC '0x"
+#ifdef HAVE_INTTYPES_H
+ "%" PRIxPTR
+#else
+ "%lu"
+#endif
+ "': filename '%s', lineno '%d', function '%s'\n",
+#ifndef HAVE_INTTYPES_H
+ (unsigned long)
+#endif
+ pc,
+ filename ?: "NULL",
+ lineno,
+ function ?: "NULL");
+
+ acc_prof_info *prof_info = (acc_prof_info *) data;
+
+ /* "backtrace.h" states that "the FILENAME and FUNCTION buffers may become
+ invalid after this function returns". But given that OpenACC 2.5 states
+ that "if the library wants to save [these], it should allocate memory and
+ copy the string[s]", it is fine to pass the pointers here. */
+ prof_info->src_file = filename;
+ prof_info->func_name = function;
+ if (lineno > 0)
+ prof_info->line_no = lineno;
+ else
+ prof_info->line_no = -1;
+
+ /* Stop here; we got what we need. */
+ return 1;
+}
+
+void goacc_profiling_locinfo_fill (struct goacc_thread *thr,
+ acc_prof_info *prof_info, int skip)
+{
+ /* Default: all unknown. */
+ prof_info->src_file = NULL;
+ prof_info->func_name = NULL;
+ prof_info->line_no = -1;
+ prof_info->end_line_no = -1;
+ prof_info->func_line_no = -1;
+ prof_info->func_end_line_no = -1;
+
+ if (!BACKTRACE_SUPPORTED)
+ {
+ /* We diagnosed this in goacc_profiling_locinfo_initialize. */
+ return;
+ }
+
+ /* Special case for oacc-init.c:acc_init_1. */
+ /* See also oacc-profiling.c:goacc_profiling_setup_p. */
+ if (__builtin_expect (thr == NULL, false))
+ {
+ gomp_debug (0, "Can't look up location information for"
+ " the current call, construct, or directive\n");
+ return;
+ }
+
+ goacc_profiling_locinfo_initialize_thr (thr);
+
+ backtrace_full (thr->backtrace_state, skip, full_callback, error_callback, prof_info);
+}
diff --git libgomp/oacc-profiling.c libgomp/oacc-profiling.c
new file mode 100644
index 000000000000..6cbc766efd3e
--- /dev/null
+++ libgomp/oacc-profiling.c
@@ -0,0 +1,650 @@
+/* Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+/* OpenACC Profiling Interface. */
+
+#define _GNU_SOURCE
+#include "libgomp.h"
+#include "oacc-int.h"
+#include "secure_getenv.h"
+#include "acc_prof.h"
+#include <assert.h>
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+#ifdef PLUGIN_SUPPORT
+# include <dlfcn.h>
+#endif
+
+#define STATIC_ASSERT(expr) _Static_assert (expr, "!(" #expr ")")
+
+/* Statically assert that the layout of the common fields in the
+ "acc_event_info" variants matches. */
+/* event_type */
+STATIC_ASSERT (offsetof (acc_event_info, event_type)
+ == offsetof (acc_event_info, data_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, launch_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, other_event.event_type));
+/* valid_bytes */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, launch_event.valid_bytes));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, other_event.valid_bytes));
+/* parent_construct */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, launch_event.parent_construct));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, other_event.parent_construct));
+/* implicit */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, launch_event.implicit));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, other_event.implicit));
+/* tool_info */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, launch_event.tool_info));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, other_event.tool_info));
+
+struct goacc_prof_callback_entry
+{
+ acc_prof_callback cb;
+ int ref;
+ bool enabled;
+ struct goacc_prof_callback_entry *next;
+};
+
+/* Using a separate flag to minimize run-time performance impact in the (very
+ common) case that profiling is not enabled. */
+static bool goacc_prof_enabled;
+/* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global toggle. */
+static bool goacc_prof_callbacks_enabled[acc_ev_last];
+static struct goacc_prof_callback_entry *goacc_prof_callback_entries[acc_ev_last];
+
+/* This lock is used to protect access to goacc_prof_callbacks_enabled, and
+ goacc_prof_callback_entries. */
+static gomp_mutex_t goacc_prof_lock;
+
+void
+goacc_profiling_initialize (void)
+{
+ gomp_mutex_init (&goacc_prof_lock);
+
+ /* Initially, all callbacks for all events are enabled. */
+ for (int i = 0; i < acc_ev_last; ++i)
+ goacc_prof_callbacks_enabled[i] = true;
+ /* ..., but profiling is still disabled. */
+ __atomic_store_n (&goacc_prof_enabled, false, MEMMODEL_RELAXED);
+
+ /* We are to invoke an external acc_register_library routine, defaulting to
+ our stub oacc-profiling-acc_register_library.c:acc_register_library
+ implementation. */
+ gomp_debug (0, "%s: calling acc_register_library\n", __FUNCTION__);
+ acc_register_library (acc_prof_register, acc_prof_unregister, NULL);
+#ifdef PLUGIN_SUPPORT
+ char *acc_proflibs = secure_getenv ("ACC_PROFLIB");
+ while (acc_proflibs != NULL && acc_proflibs[0] != '\0')
+ {
+ char *acc_proflibs_sep = strchr (acc_proflibs, ';');
+ char *acc_proflib;
+ if (acc_proflibs_sep == acc_proflibs)
+ {
+ /* Stray ";" separator: make sure we don't dlopen the main
+ program. */
+ acc_proflib = NULL;
+ }
+ else
+ {
+ if (acc_proflibs_sep != NULL)
+ {
+ /* Single out the first library. */
+ acc_proflib = gomp_malloc (acc_proflibs_sep - acc_proflibs + 1);
+ memcpy (acc_proflib, acc_proflibs,
+ acc_proflibs_sep - acc_proflibs);
+ acc_proflib[acc_proflibs_sep - acc_proflibs] = '\0';
+ }
+ else
+ {
+ /* No ";" separator, so only one library. */
+ acc_proflib = acc_proflibs;
+ }
+
+ gomp_debug (0, "%s: dlopen(%s)\n", __FUNCTION__, acc_proflib);
+ void *dl_handle = dlopen (acc_proflib, RTLD_LAZY);
+ if (dl_handle != NULL)
+ {
+ typeof (&acc_register_library) a_r_l
+ = dlsym (dl_handle, "acc_register_library");
+ if (a_r_l == NULL)
+ goto dl_fail;
+ /* Avoid duplicate registration, for example if the same shared
+ library is specified in LD_PRELOAD and ACC_PROFLIB -- which
+ TAU 2.26 does when using "tau_exec -openacc". */
+ if (a_r_l == acc_register_library)
+ gomp_debug (0, " %s: skipping duplicate"
+ " %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ else
+ {
+ gomp_debug (0, " %s: calling %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ a_r_l (acc_prof_register, acc_prof_unregister, NULL);
+ }
+ }
+ else
+ {
+ dl_fail:
+ gomp_error ("while loading ACC_PROFLIB %s: %s",
+ acc_proflib, dlerror ());
+ if (dl_handle != NULL)
+ {
+ int err = dlclose (dl_handle);
+ dl_handle = NULL;
+ if (err != 0)
+ goto dl_fail;
+ }
+ }
+ }
+
+ if (acc_proflib != acc_proflibs)
+ {
+ free (acc_proflib);
+
+ acc_proflibs = acc_proflibs_sep + 1;
+ }
+ else
+ acc_proflibs = NULL;
+ }
+#endif /* PLUGIN_SUPPORT */
+
+ goacc_profiling_locinfo_initialize ();
+}
+
+void
+acc_prof_register (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ __atomic_store_n (&goacc_prof_enabled, true, MEMMODEL_RELAXED);
+
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+ enum
+ {
+ EVENT_KIND_BOGUS,
+ EVENT_KIND_NORMAL,
+ /* As end events invoke callbacks in the reverse order, we register these
+ in the reverse order here. */
+ EVENT_KIND_END,
+ } event_kind = EVENT_KIND_BOGUS;
+ switch (ev)
+ {
+ case acc_ev_none:
+ case acc_ev_device_init_start:
+ case acc_ev_device_shutdown_start:
+ case acc_ev_runtime_shutdown:
+ case acc_ev_create:
+ case acc_ev_delete:
+ case acc_ev_alloc:
+ case acc_ev_free:
+ case acc_ev_enter_data_start:
+ case acc_ev_exit_data_start:
+ case acc_ev_update_start:
+ case acc_ev_compute_construct_start:
+ case acc_ev_enqueue_launch_start:
+ case acc_ev_enqueue_upload_start:
+ case acc_ev_enqueue_download_start:
+ case acc_ev_wait_start:
+ event_kind = EVENT_KIND_NORMAL;
+ break;
+ case acc_ev_device_init_end:
+ case acc_ev_device_shutdown_end:
+ case acc_ev_enter_data_end:
+ case acc_ev_exit_data_end:
+ case acc_ev_update_end:
+ case acc_ev_compute_construct_end:
+ case acc_ev_enqueue_launch_end:
+ case acc_ev_enqueue_upload_end:
+ case acc_ev_enqueue_download_end:
+ case acc_ev_wait_end:
+ event_kind = EVENT_KIND_END;
+ break;
+ case acc_ev_last:
+ break;
+ }
+ if (event_kind == EVENT_KIND_BOGUS)
+ {
+ gomp_error ("ignoring %s request for invalid acc_event_t %d",
+ __FUNCTION__, (int) ev);
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ gomp_error ("ignoring %s request with invalid acc_register_t %d",
+ __FUNCTION__, (int) reg);
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally enabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global
+ toggle. */
+ goacc_prof_callbacks_enabled[ev] = true;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ /* Silently ignore request. */
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: enabling callbacks\n");
+ goacc_lazy_initialize (1);
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = true;
+ return;
+ }
+ gomp_error ("ignoring %s request for acc_toggle_per_thread",
+ __FUNCTION__);
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ /* If we already have this callback registered, just increment its ref
+ count. */
+ if (it != NULL)
+ {
+ it->ref++;
+ gomp_debug (0, " already registered;"
+ " incrementing ref count to: %d\n", it->ref);
+ }
+ else
+ {
+ struct goacc_prof_callback_entry *e
+ = gomp_malloc (sizeof (struct goacc_prof_callback_entry));
+ e->cb = cb;
+ e->ref = 1;
+ e->enabled = true;
+ bool prepend = (event_kind == EVENT_KIND_END);
+ /* If we don't have any callback registered yet, also use the
+ "prepend" code path. */
+ if (it_p == NULL)
+ prepend = true;
+ if (prepend)
+ {
+ gomp_debug (0, " prepending\n");
+ e->next = goacc_prof_callback_entries[ev];
+ goacc_prof_callback_entries[ev] = e;
+ }
+ else
+ {
+ gomp_debug (0, " appending\n");
+ e->next = NULL;
+ it_p->next = e;
+ }
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ /* Silently ignore acc_toggle request if not registered. */
+ gomp_debug (0, " not enabling; not registered\n");
+ }
+ else
+ {
+ gomp_debug (0, " enabling\n");
+ it->enabled = true;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+void
+acc_prof_unregister (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+ if (ev < acc_ev_none
+ || ev >= acc_ev_last)
+ {
+ gomp_error ("ignoring %s request for invalid acc_event_t %d",
+ __FUNCTION__, (int) ev);
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ gomp_error ("ignoring %s request with invalid acc_register_t %d",
+ __FUNCTION__, (int) reg);
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally disabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global
+ toggle. */
+ goacc_prof_callbacks_enabled[ev] = false;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ /* Silently ignore request. */
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: disabling callbacks\n");
+ goacc_lazy_initialize (1);
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = false;
+ return;
+ }
+ gomp_error ("ignoring %s request for acc_toggle_per_thread",
+ __FUNCTION__);
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ if (it == NULL)
+ {
+ gomp_error ("ignoring %s request for acc_event_t %d: not registered",
+ __FUNCTION__, (int) ev);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ it->ref--;
+ gomp_debug (0, " decrementing ref count to: %d\n", it->ref);
+ if (it->ref == 0)
+ {
+ if (it_p == NULL)
+ goacc_prof_callback_entries[ev] = it->next;
+ else
+ it_p->next = it->next;
+ free (it);
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ /* Silently ignore acc_toggle request if not registered. */
+ gomp_debug (0, " not disabling; not registered\n");
+ }
+ else
+ {
+ gomp_debug (0, " disabling\n");
+ it->enabled = false;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+/* Set up to dispatch events? */
+
+bool
+goacc_profiling_setup_p (struct goacc_thread *thr,
+ acc_prof_info *prof_info, acc_api_info *api_info,
+ int acc_prof_locinfo_skip)
+{
+ gomp_debug (0, "%s (%p)\n", __FUNCTION__, thr);
+
+ /* If we don't have any per-thread state yet, we can't register prof_info and
+ api_info. */
+ /* See also oacc-profiling-locinfo.c:goacc_profiling_locinfo_fill. */
+ if (__builtin_expect (thr == NULL, false))
+ {
+ gomp_debug (0, "Can't generate OpenACC Profiling Interface events for"
+ " the current call, construct, or directive\n");
+ return false;
+ }
+
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (false), false);
+ if (thr->prof_info != NULL)
+ {
+ assert (profiling_dispatch_p);
+ /* Profiling has already been set up for an outer construct. In this
+ case, we continue to use the existing information, and thus return
+ "false" here.
+
+ This can happen, for example, for an enter data directive, which sets
+ up profiling, then calls into acc_copyin, which should not again set
+ up profiling, should not overwrite the existing information. */
+ return false;
+ }
+
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = prof_info;
+
+ prof_info->event_type = -1; /* Must be set later. */
+ prof_info->valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info->version = _ACC_PROF_INFO_VERSION;
+ if (thr->dev)
+ {
+ prof_info->device_type = acc_device_type (thr->dev->type);
+ prof_info->device_number = thr->dev->target_id;
+ }
+ else
+ {
+ prof_info->device_type = -1;
+ prof_info->device_number = -1;
+ }
+ prof_info->thread_id = -1;
+ prof_info->async = acc_async_sync;
+ prof_info->async_queue = prof_info->async;
+ goacc_profiling_locinfo_fill (thr, prof_info, acc_prof_locinfo_skip + 1);
+
+ thr->api_info = api_info;
+
+ api_info->device_api = acc_device_api_none;
+ api_info->valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info->device_type = prof_info->device_type;
+ api_info->vendor = -1;
+ api_info->device_handle = NULL;
+ api_info->context_handle = NULL;
+ api_info->async_handle = NULL;
+ }
+
+ return profiling_dispatch_p;
+}
+
+/* Prepare to dispatch events? */
+
+bool
+goacc_profiling_dispatch_p (bool check_not_nested_p)
+{
+ if (__builtin_expect (__atomic_load_n (&goacc_prof_enabled,
+ MEMMODEL_RELAXED) != true, true))
+ return false;
+
+ gomp_debug (0, "%s\n", __FUNCTION__);
+
+ struct goacc_thread *thr = goacc_thread ();
+ if (__builtin_expect (thr == NULL, false))
+ {
+ /* If we don't have any per-thread state yet, that means that per-thread
+ callback dispatch has not been explicitly disabled (which only a call
+ to acc_prof_unregister with acc_toggle_per_thread will do, and that
+ would have allocated per-thread state via goacc_lazy_initialize);
+ initially, all callbacks for all events are enabled. */
+ gomp_debug (0, " %s: don't have any per-thread state yet\n", __FUNCTION__);
+ }
+ else
+ {
+ if (check_not_nested_p)
+ {
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ }
+
+ if (__builtin_expect (!thr->prof_callbacks_enabled, true))
+ {
+ gomp_debug (0, " %s: disabled for this thread\n", __FUNCTION__);
+ return false;
+ }
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global toggle. */
+ if (__builtin_expect (!goacc_prof_callbacks_enabled[acc_ev_none], true))
+ {
+ gomp_debug (0, " %s: disabled globally\n", __FUNCTION__);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return false;
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+
+ return true;
+}
+
+/* Dispatch events.
+
+ This must only be called if goacc_profiling_dispatch_p returned a true
+ result. */
+
+void
+goacc_profiling_dispatch (acc_prof_info *prof_info, acc_event_info *event_info,
+ acc_api_info *apt_info)
+{
+ acc_event_t event_type = event_info->event_type;
+ gomp_debug (0, "%s: event_type=%d\n", __FUNCTION__, (int) event_type);
+ assert (event_type > acc_ev_none
+ && event_type < acc_ev_last);
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ if (!goacc_prof_callbacks_enabled[event_type])
+ {
+ gomp_debug (0, " %s: disabled for this event type\n", __FUNCTION__);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+
+ for (struct goacc_prof_callback_entry *e
+ = goacc_prof_callback_entries[event_type];
+ e != NULL;
+ e = e->next)
+ {
+ if (!e->enabled)
+ {
+ gomp_debug (0, " %s: disabled for callback %p\n",
+ __FUNCTION__, e->cb);
+ continue;
+ }
+
+ gomp_debug (0, " %s: calling callback %p\n", __FUNCTION__, e->cb);
+ e->cb (prof_info, event_info, apt_info);
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
diff --git libgomp/plugin/plugin-nvptx.c libgomp/plugin/plugin-nvptx.c
index 6aac13cca960..f036d04a5e9d 100644
--- libgomp/plugin/plugin-nvptx.c
+++ libgomp/plugin/plugin-nvptx.c
@@ -36,6 +36,7 @@
#include "libgomp-plugin.h"
#include "oacc-plugin.h"
#include "gomp-constants.h"
+#include "oacc-int.h"
#include <pthread.h>
#include <cuda.h>
@@ -861,11 +862,52 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
// num_workers ntid.y
// vector length ntid.x
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info enqueue_launch_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_start;
+
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ enqueue_launch_event_info.launch_event.valid_bytes
+ = _ACC_LAUNCH_EVENT_INFO_VALID_BYTES;
+ enqueue_launch_event_info.launch_event.parent_construct
+ = acc_construct_parallel;
+ enqueue_launch_event_info.launch_event.implicit = 1;
+ enqueue_launch_event_info.launch_event.tool_info = NULL;
+ enqueue_launch_event_info.launch_event.kernel_name
+ = targ_fn->launch->fn;
+ enqueue_launch_event_info.launch_event.num_gangs
+ = dims[GOMP_DIM_GANG];
+ enqueue_launch_event_info.launch_event.num_workers
+ = dims[GOMP_DIM_WORKER];
+ enqueue_launch_event_info.launch_event.vector_length
+ = dims[GOMP_DIM_VECTOR];
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
+
CUDA_CALL_ASSERT (cuLaunchKernel, function,
dims[GOMP_DIM_GANG], 1, 1,
dims[GOMP_DIM_VECTOR], dims[GOMP_DIM_WORKER], 1,
0, stream, kargs, 0);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_end;
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
+
GOMP_PLUGIN_debug (0, " %s: kernel %s: finished\n", __FUNCTION__,
targ_fn->launch->fn);
}
@@ -878,6 +920,36 @@ nvptx_alloc (size_t s)
CUdeviceptr d;
CUDA_CALL_ERET (NULL, cuMemAlloc, &d, s);
+
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ bool profiling_dispatch_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_alloc;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel;
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL;
+ data_event_info.data_event.bytes = s;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = (void *) d;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
return (void *) d;
}
@@ -1253,11 +1325,47 @@ openacc_exec_internal (void (*fn) (void *), int params, size_t mapnum,
/* Copy the (device) pointers to arguments to the device (dp and hp might in
fact have the same value on a unified-memory system). */
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel;
+ /* Always implicit for "data mapping arguments for cuLaunchKernel". */
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL;
+ data_event_info.data_event.bytes = mapnum * sizeof (void *);
+ data_event_info.data_event.host_ptr = hp;
+ if (!params)
+ data_event_info.data_event.device_ptr = (void *) dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
if (!params && mapnum > 0)
CUDA_CALL_ASSERT (cuMemcpyHtoD, dp, (void *) hp,
mapnum * sizeof (void *));
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
if (params)
nvptx_exec (fn, mapnum, hostaddrs, devaddrs, dims, targ_mem_desc,
hp, NULL);
@@ -1338,6 +1446,34 @@ openacc_async_exec_internal (void (*fn) (void *), int params, size_t mapnum,
/* Copy the (device) pointers to arguments to the device (dp and hp might in
fact have the same value on a unified-memory system). */
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel;
+ /* Always implicit for "data mapping arguments for cuLaunchKernel". */
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL;
+ data_event_info.data_event.bytes = mapnum * sizeof (void *);
+ data_event_info.data_event.host_ptr = hp;
+ if (!params)
+ data_event_info.data_event.device_ptr = (void *) dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
if (!params && mapnum > 0)
{
@@ -1350,6 +1486,14 @@ openacc_async_exec_internal (void (*fn) (void *), int params, size_t mapnum,
block[1] = (void *) nvthd->ptx_dev;
}
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
if (params)
nvptx_exec (fn, mapnum, hostaddrs, devaddrs, dims, targ_mem_desc,
hp, aq->cuda_stream);
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
new file mode 100644
index 000000000000..bf31a4385597
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
@@ -0,0 +1,350 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+void cb_compute_construct_start_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 10
+ || state == 30
+ || state == 41
+ || state == 51
+ || state == 91
+ || state == 101
+ || state == 151);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_start_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 11
+ || state == 40
+ || state == 50
+ || state == 90
+ || state == 100
+ || state == 150);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 14
+ || state == 21
+ || state == 32
+ || state == 42
+ || state == 80
+ || state == 103
+ || state == 152);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 13
+ || state == 43
+ || state == 102
+ || state == 154);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_3 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 12
+ || state == 20
+ || state == 31
+ || state == 44
+ || state == 81
+ || state == 104
+ || state == 153);
+ STATE_OP (state, ++);
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 2);
+ }
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 12);
+ }
+ assert (state == 15);
+
+ STATE_OP (state, = 20);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 20);
+ }
+ assert (state == 20);
+
+ STATE_OP (state, = 30);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 31);
+ }
+ assert (state == 33);
+
+ STATE_OP (state, = 40);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 42);
+ }
+ assert (state == 45);
+
+ STATE_OP (state, = 50);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 52);
+ }
+ assert (state == 52);
+
+ STATE_OP (state, = 60);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 60);
+ }
+ assert (state == 60);
+
+ STATE_OP (state, = 70);
+ unreg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 70);
+ }
+ assert (state == 70);
+
+ STATE_OP (state, = 80);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 80);
+ }
+ assert (state == 82);
+
+ STATE_OP (state, = 90);
+ reg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 92);
+ }
+ assert (state == 92);
+
+ STATE_OP (state, = 100);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 102);
+ }
+ assert (state == 105);
+
+ STATE_OP (state, = 110);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 110);
+ }
+ assert (state == 110);
+
+ STATE_OP (state, = 120);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 120);
+ }
+ assert (state == 120);
+
+ STATE_OP (state, = 130);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 130);
+ }
+ assert (state == 130);
+
+ STATE_OP (state, = 140);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 140);
+ }
+ assert (state == 140);
+
+ STATE_OP (state, = 150);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 152);
+ }
+ assert (state == 155);
+
+ return 0;
+}
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1-debug_info.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1-debug_info.c
new file mode 100644
index 000000000000..f43e526dde0e
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1-debug_info.c
@@ -0,0 +1,5 @@
+/* Test "acc_prof-init-1.c" with debug info available. */
+
+/* { dg-additional-options "-g -DDEBUG_INFO=1" } */
+
+#include "acc_prof-init-1.c"
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
new file mode 100644
index 000000000000..ec5bcf6a90e5
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
@@ -0,0 +1,388 @@
+/* Test dispatch of events to callbacks. */
+
+/* If not included from "acc_prof-parallel-1-debug_info.c". */
+#ifndef DEBUG_INFO
+# define DEBUG_INFO 0
+#endif
+
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+
+static const char *acc_prof_src_file = NULL;
+static const char *acc_prof_func_name = NULL;
+static int acc_prof_line_no = -1;
+
+static void
+set_locinfo (const char *src_file, const char *func_name, int line_no)
+{
+ assert (acc_prof_src_file == NULL);
+ acc_prof_src_file = src_file;
+ assert (acc_prof_func_name == NULL);
+ acc_prof_func_name = func_name;
+ assert (acc_prof_line_no == -1);
+ acc_prof_line_no = line_no;
+}
+
+static void
+unset_locinfo ()
+{
+ assert (acc_prof_src_file != NULL);
+ acc_prof_src_file = NULL;
+ assert (acc_prof_func_name != NULL);
+ acc_prof_func_name = NULL;
+ assert (acc_prof_line_no != -1);
+ acc_prof_line_no = -1;
+}
+
+static void
+verify_locinfo (const acc_prof_info *prof_info)
+{
+ DEBUG_printf (" acc_prof_src_file: '%s'\n", acc_prof_src_file ?: "NULL");
+ DEBUG_printf (" prof_info->src_file: '%s'\n", prof_info->src_file ?: "NULL");
+ DEBUG_printf (" acc_prof_func_name: '%s'\n", acc_prof_func_name ?: "NULL");
+ DEBUG_printf (" prof_info->func_name: '%s'\n", prof_info->func_name ?: "NULL");
+ DEBUG_printf (" acc_prof_line_no: '%d'\n", acc_prof_line_no);
+ DEBUG_printf (" prof_info->line_no: '%d'\n", prof_info->line_no);
+
+ assert (acc_prof_src_file != NULL);
+ assert (acc_prof_func_name != NULL);
+ assert (acc_prof_line_no != -1);
+#if DEBUG_INFO
+ assert (prof_info->src_file != NULL);
+ assert (strcmp (prof_info->src_file, acc_prof_src_file) == 0);
+ assert (prof_info->func_name != NULL);
+ assert (strcmp (prof_info->func_name, acc_prof_func_name) == 0);
+ assert (prof_info->line_no == acc_prof_line_no);
+#else
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+#endif
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+}
+
+
+void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 1)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+#if DEBUG_INFO
+ //TODO verify_locinfo (prof_info);
+#else
+ verify_locinfo (prof_info);
+#endif
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 2)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+#if DEBUG_INFO
+ //TODO verify_locinfo (prof_info);
+#else
+ verify_locinfo (prof_info);
+#endif
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 10
+ || state == 110);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ verify_locinfo (prof_info);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 11
+ || state == 111);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ verify_locinfo (prof_info);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ assert (state == 0);
+
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+ acc_init (acc_device_host);
+ unset_locinfo ();
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+ acc_device_type = acc_get_device_type ();
+ unset_locinfo ();
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+ acc_device_num = acc_get_device_num (acc_device_type);
+ unset_locinfo ();
+ acc_async = 12;
+
+ {
+ int state_init;
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ unset_locinfo ();
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+#pragma acc wait
+ unset_locinfo ();
+ assert (state_init == 11);
+ }
+ assert (state == 12);
+
+ STATE_OP (state, = 90);
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+ acc_shutdown (acc_device_host);
+ unset_locinfo ();
+ assert (state == 90);
+
+
+ STATE_OP (state, = 100);
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+ acc_init (acc_device_default);
+ unset_locinfo ();
+ assert (state == 102);
+
+ STATE_OP (state, = 110);
+
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+ acc_device_type = acc_get_device_type ();
+ unset_locinfo ();
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+ acc_device_num = acc_get_device_num (acc_device_type);
+ unset_locinfo ();
+ acc_async = 12;
+
+ {
+ int state_init;
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ unset_locinfo ();
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+#pragma acc wait
+ unset_locinfo ();
+ assert (state_init == 111);
+ }
+ assert (state == 112);
+
+ STATE_OP (state, = 190);
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+ acc_shutdown (acc_device_default);
+ unset_locinfo ();
+ assert (state == 190);
+
+ return 0;
+}
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
new file mode 100644
index 000000000000..28cea048a1aa
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
@@ -0,0 +1,252 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+/* See the "DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT" reference in
+ libgomp.texi. */
+#define DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT 0
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int num_gangs, num_workers, vector_length;
+
+
+void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 0);
+ STATE_OP (state, = 1);
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == NULL);
+ assert (event_info->launch_event.kernel_name != NULL);
+ {
+ const char *s = strstr (event_info->launch_event.kernel_name, "main");
+ assert (s != NULL);
+ s = strstr (s, "omp_fn");
+ assert (s != NULL);
+ }
+ if (num_gangs < 1)
+ assert (event_info->launch_event.num_gangs >= 1);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.num_gangs == num_gangs);
+#else
+ /* No parallelized OpenACC kernels constructs, and unparallelized OpenACC
+ kernels constructs must get launched as 1 x 1 x 1 kernels. */
+ assert (event_info->launch_event.num_gangs == 1);
+#endif
+ }
+ if (num_workers < 1)
+ assert (event_info->launch_event.num_workers >= 1);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.num_workers == num_workers);
+#else
+ /* See num_gangs above. */
+ assert (event_info->launch_event.num_workers == 1);
+#endif
+ }
+ if (vector_length < 1)
+ assert (event_info->launch_event.vector_length >= 1);
+ else if (acc_device_type == acc_device_nvidia) /* ... is special. */
+ assert (event_info->launch_event.vector_length == 32);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.vector_length == vector_length);
+#else
+ /* See num_gangs above. */
+ assert (event_info->launch_event.vector_length == 1);
+#endif
+ }
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
+ assert (state == 0);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ assert (state == 0);
+
+ /* Parallelism dimensions: compiler/runtime decides. */
+ STATE_OP (state, = 0);
+ num_gangs = num_workers = vector_length = 0;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No acc_ev_enqueue_launch_start. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ /* Parallelism dimensions: literal. */
+ STATE_OP (state, = 0);
+ num_gangs = 30;
+ num_workers = 3;
+ vector_length = 5;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels \
+ num_gangs (30) num_workers (3) vector_length (5)
+ /* { dg-prune-output "using vector_length \\(32\\), ignoring 5" } */
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No acc_ev_enqueue_launch_start. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ /* Parallelism dimensions: variable. */
+ STATE_OP (state, = 0);
+ num_gangs = 22;
+ num_workers = 5;
+ vector_length = 7;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels \
+ num_gangs (num_gangs) num_workers (num_workers) vector_length (vector_length)
+ /* { dg-prune-output "using vector_length \\(32\\), ignoring runtime setting" } */
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No acc_ev_enqueue_launch_start. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ return 0;
+}
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1-debug_info.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1-debug_info.c
new file mode 100644
index 000000000000..19226449d932
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1-debug_info.c
@@ -0,0 +1,5 @@
+/* Test "acc_prof-parallel-1.c" with debug info available. */
+
+/* { dg-additional-options "-g -DDEBUG_INFO=1" } */
+
+#include "acc_prof-parallel-1.c"
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
new file mode 100644
index 000000000000..2b3cb3e16bc5
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
@@ -0,0 +1,737 @@
+/* Test dispatch of events to callbacks. */
+
+/* If not included from "acc_prof-parallel-1-debug_info.c". */
+#ifndef DEBUG_INFO
+# define DEBUG_INFO 0
+#endif
+
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+/* See the "DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT" reference in
+ libgomp.texi. */
+#define DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT 0
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+
+static const char *acc_prof_src_file = NULL;
+static const char *acc_prof_func_name = NULL;
+static int acc_prof_line_no = -1;
+
+static void
+set_locinfo (const char *src_file, const char *func_name, int line_no)
+{
+ assert (acc_prof_src_file == NULL);
+ acc_prof_src_file = src_file;
+ assert (acc_prof_func_name == NULL);
+ acc_prof_func_name = func_name;
+ assert (acc_prof_line_no == -1);
+ acc_prof_line_no = line_no;
+}
+
+static void
+unset_locinfo ()
+{
+ assert (acc_prof_src_file != NULL);
+ acc_prof_src_file = NULL;
+ assert (acc_prof_func_name != NULL);
+ acc_prof_func_name = NULL;
+ assert (acc_prof_line_no != -1);
+ acc_prof_line_no = -1;
+}
+
+static void
+verify_locinfo (const acc_prof_info *prof_info)
+{
+ DEBUG_printf (" acc_prof_src_file: '%s'\n", acc_prof_src_file ?: "NULL");
+ DEBUG_printf (" prof_info->src_file: '%s'\n", prof_info->src_file ?: "NULL");
+ DEBUG_printf (" acc_prof_func_name: '%s'\n", acc_prof_func_name ?: "NULL");
+ DEBUG_printf (" prof_info->func_name: '%s'\n", prof_info->func_name ?: "NULL");
+ DEBUG_printf (" acc_prof_line_no: '%d'\n", acc_prof_line_no);
+ DEBUG_printf (" prof_info->line_no: '%d'\n", prof_info->line_no);
+
+ assert (acc_prof_src_file != NULL);
+ assert (acc_prof_func_name != NULL);
+ assert (acc_prof_line_no != -1);
+#if DEBUG_INFO
+ assert (prof_info->src_file != NULL);
+ assert (strcmp (prof_info->src_file, acc_prof_src_file) == 0);
+ assert (prof_info->func_name != NULL);
+ assert (strcmp (prof_info->func_name, acc_prof_func_name) == 0);
+ assert (prof_info->line_no == acc_prof_line_no);
+#else
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+#endif
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+}
+
+
+void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+#else
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+#if DEBUG_INFO
+ //TODO verify_locinfo (prof_info);
+#else
+ verify_locinfo (prof_info);
+#endif
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+#else
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+#endif
+}
+
+void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 2
+ || state == 102);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_device_init_start);
+#else
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+#if DEBUG_INFO
+ //TODO verify_locinfo (prof_info);
+#else
+ verify_locinfo (prof_info);
+#endif
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (event_info->other_event.tool_info == tool_info->nested);
+#else
+ assert (event_info->other_event.tool_info == tool_info);
+#endif
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+#else
+ free (tool_info);
+ tool_info = NULL;
+#endif
+}
+
+void cb_enter_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 3
+ || state == 103);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enter_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ verify_locinfo (prof_info);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_enter_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 4
+ || state == 104);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_enter_data_start);
+
+ assert (prof_info->event_type == acc_ev_enter_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ verify_locinfo (prof_info);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+void cb_exit_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 7);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_exit_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ verify_locinfo (prof_info);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_exit_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 8);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_exit_data_start);
+
+ assert (prof_info->event_type == acc_ev_exit_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ verify_locinfo (prof_info);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 0
+ || state == 100);
+ if (state == 100)
+ {
+ /* Compensate for the missing acc_ev_device_init_start and
+ acc_ev_device_init_end. */
+ state += 2;
+ }
+#else
+ if (state == 100)
+ {
+ /* Compensate for the missing acc_ev_device_init_start and
+ acc_ev_device_init_end. */
+ state += 2;
+ }
+ assert (state == 2
+ || state == 102);
+#endif
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ verify_locinfo (prof_info);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing acc_ev_enter_data_start. */
+ state += 1;
+ }
+}
+
+void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing acc_ev_enter_data_end. */
+ state += 1;
+ /* Compensate for the missing acc_ev_enqueue_launch_start and
+ acc_ev_enqueue_launch_end. */
+ state += 2;
+ /* Compensate for the missing acc_ev_exit_data_start and
+ acc_ev_exit_data_end. */
+ state += 2;
+ }
+ else if (acc_async != acc_async_sync)
+ {
+ /* Compensate for the missing acc_ev_exit_data_start and
+ acc_ev_exit_data_end. */
+ state += 2;
+ }
+ assert (state == 9
+ || state == 109);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ verify_locinfo (prof_info);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 5
+ || state == 105);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ verify_locinfo (prof_info);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == NULL);
+ assert (event_info->launch_event.kernel_name != NULL);
+ {
+ const char *s = strstr (event_info->launch_event.kernel_name, "main");
+ assert (s != NULL);
+ s = strstr (s, "omp_fn");
+ assert (s != NULL);
+ }
+ assert (event_info->launch_event.num_gangs >= 1);
+ assert (event_info->launch_event.num_workers >= 1);
+ assert (event_info->launch_event.vector_length >= 1);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.launch_event.event_type = event_info->launch_event.event_type;
+ tool_info->nested->event_info.launch_event.kernel_name = strdup (event_info->launch_event.kernel_name);
+ tool_info->nested->event_info.launch_event.num_gangs = event_info->launch_event.num_gangs;
+ tool_info->nested->event_info.launch_event.num_workers = event_info->launch_event.num_workers;
+ tool_info->nested->event_info.launch_event.vector_length = event_info->launch_event.vector_length;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_enqueue_launch_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 6
+ || state == 106);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.launch_event.event_type == acc_ev_enqueue_launch_start);
+ assert (tool_info->nested->event_info.launch_event.kernel_name != NULL);
+ assert (tool_info->nested->event_info.launch_event.num_gangs >= 1);
+ assert (tool_info->nested->event_info.launch_event.num_workers >= 1);
+ assert (tool_info->nested->event_info.launch_event.vector_length >= 1);
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ verify_locinfo (prof_info);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == tool_info->nested);
+ assert (event_info->launch_event.kernel_name != NULL);
+ assert (strcmp (event_info->launch_event.kernel_name, tool_info->nested->event_info.launch_event.kernel_name) == 0);
+ assert (event_info->launch_event.num_gangs == tool_info->nested->event_info.launch_event.num_gangs);
+ assert (event_info->launch_event.num_workers == tool_info->nested->event_info.launch_event.num_workers);
+ assert (event_info->launch_event.vector_length == tool_info->nested->event_info.launch_event.vector_length);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free ((void *) tool_info->nested->event_info.launch_event.kernel_name);
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_enter_data_start, cb_enter_data_start, acc_reg);
+ reg (acc_ev_enter_data_end, cb_enter_data_end, acc_reg);
+ reg (acc_ev_exit_data_start, cb_exit_data_start, acc_reg);
+ reg (acc_ev_exit_data_end, cb_exit_data_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
+ reg (acc_ev_enqueue_launch_end, cb_enqueue_launch_end, acc_reg);
+ assert (state == 0);
+
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+ acc_device_type = acc_get_device_type ();
+ unset_locinfo ();
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+ acc_device_num = acc_get_device_num (acc_device_type);
+ unset_locinfo ();
+ acc_async = acc_async_sync;
+ assert (state == 0);
+
+ {
+ int state_init;
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ unset_locinfo ();
+ assert (state_init == 4);
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ assert (state == 10);
+
+ STATE_OP (state, = 100);
+
+ acc_async = 12;
+ {
+ int state_init;
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ unset_locinfo ();
+ set_locinfo (__FILE__, __func__, __LINE__ + 1);
+#pragma acc wait
+ unset_locinfo ();
+ assert (state_init == 104);
+ }
+ assert (state == 110);
+
+ return 0;
+}
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
new file mode 100644
index 000000000000..e2bf38e26799
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
@@ -0,0 +1,178 @@
+/* Test the "valid_bytes" magic. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+void cb_data_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->data_event.valid_bytes == _ACC_DATA_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+void cb_launch_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+void cb_other_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_other_event, acc_reg);
+ reg_ (acc_ev_create, cb_data_event, acc_reg);
+ reg_ (acc_ev_delete, cb_data_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_data_event, acc_reg);
+ reg_ (acc_ev_free, cb_data_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_other_event, acc_reg);
+}
+
+
+/* Basic struct. */
+typedef struct A
+{
+ int a;
+ int b;
+#define VALID_BYTES_A \
+ _ACC_PROF_VALID_BYTES_STRUCT (A, b, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (int))
+} A;
+
+/* Add a "char" field. */
+typedef struct B
+{
+ int a;
+ int b;
+ char c;
+#define VALID_BYTES_B \
+ _ACC_PROF_VALID_BYTES_STRUCT (B, c, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} B;
+
+/* Add another "char" field. */
+typedef struct C
+{
+ int a;
+ int b;
+ char c, d;
+#define VALID_BYTES_C \
+ _ACC_PROF_VALID_BYTES_STRUCT (C, d, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} C;
+
+/* Add two "void *" fields. */
+typedef struct D
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+#define VALID_BYTES_D \
+ _ACC_PROF_VALID_BYTES_STRUCT (D, f, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} D;
+
+/* Add another three "char" fields. */
+typedef struct E
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+ char g, h, i;
+#define VALID_BYTES_E \
+ _ACC_PROF_VALID_BYTES_STRUCT (E, i, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} E;
+
+
+int main()
+{
+ A A1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof A1, VALID_BYTES_A);
+ assert (VALID_BYTES_A <= sizeof A1);
+ DEBUG_printf ("&A1=%p, &A1.b=%p\n", &A1, &A1.b);
+ assert (((char *) &A1) + VALID_BYTES_A == (char *) (&A1.b + 1));
+
+ B B1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof B1, VALID_BYTES_B);
+ assert (VALID_BYTES_B <= sizeof B1);
+ DEBUG_printf ("&B1=%p, &B1.c=%p\n", &B1, &B1.c);
+ assert (((char *) &B1) + VALID_BYTES_B == (char *) (&B1.c + 1));
+
+ assert (VALID_BYTES_B == VALID_BYTES_A + 1 * sizeof (char));
+
+ C C1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof C1, VALID_BYTES_C);
+ assert (VALID_BYTES_C <= sizeof C1);
+ DEBUG_printf ("&C1=%p, &C1.d=%p\n", &C1, &C1.d);
+ assert (((char *) &C1) + VALID_BYTES_C == (char *) (&C1.d + 1));
+
+ assert (VALID_BYTES_C == VALID_BYTES_B + 1 * sizeof (char));
+
+ D D1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof D1, VALID_BYTES_D);
+ assert (VALID_BYTES_D <= sizeof D1);
+ DEBUG_printf ("&D1=%p, &D1.f=%p\n", &D1, &D1.f);
+ assert (((char *) &D1) + VALID_BYTES_D == (char *) (&D1.f + 1));
+
+ assert (VALID_BYTES_D > VALID_BYTES_C);
+
+ E E1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof E1, VALID_BYTES_E);
+ assert (VALID_BYTES_E <= sizeof E1);
+ DEBUG_printf ("&E1=%p, &E1.i=%p\n", &E1, &E1.i);
+ assert (((char *) &E1) + VALID_BYTES_E == (char *) (&E1.i + 1));
+
+ assert (VALID_BYTES_E == VALID_BYTES_D + 3 * sizeof (char));
+
+ /* Trigger tests done in cb_* functions. */
+#pragma acc parallel
+ {
+ }
+
+ return 0;
+}
diff --git libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
new file mode 100644
index 000000000000..7c619a09689f
--- /dev/null
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
@@ -0,0 +1,60 @@
+/* Test "acc_prof_info"'s "version" field. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+void cb_any_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->version == 201510);
+}
+
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_any_event, acc_reg);
+ reg_ (acc_ev_create, cb_any_event, acc_reg);
+ reg_ (acc_ev_delete, cb_any_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_any_event, acc_reg);
+ reg_ (acc_ev_free, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_any_event, acc_reg);
+}
+
+
+int main()
+{
+ /* Trigger tests done in cb_* functions. */
+#pragma acc parallel
+ {
+ }
+
+ return 0;
+}
Grüße
Thomas
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: OpenACC 2.5 Profiling Interface
2018-11-12 4:32 ` OpenACC 2.5 Profiling Interface Thomas Schwinge
@ 2018-12-04 13:13 ` Jakub Jelinek
2019-05-15 14:28 ` Thomas Schwinge
2019-05-16 15:22 ` OpenACC Profiling Interface: 'acc_register_library' (was: OpenACC 2.5 Profiling Interface) Thomas Schwinge
1 sibling, 1 reply; 23+ messages in thread
From: Jakub Jelinek @ 2018-12-04 13:13 UTC (permalink / raw)
To: Thomas Schwinge; +Cc: gcc-patches
On Sun, Nov 11, 2018 at 10:31:42PM -0600, Thomas Schwinge wrote:
> On Tue, 28 Feb 2017 18:43:36 +0100, I wrote:
> > The 2.5 versions of the OpenACC standard added a new chapter "Profiling
> > Interface".
>
> I'd like to get that into trunk. It's not yet complete (that is, doesn't
> provide all the information specified), but it's very useful already, and
> the missing pieces can later be added incrementally.
>
> Jakub, would you please especially review the non-OpenACC-specific
> changes here, including the libgomp ABI changes?
>
> (Note that this patch doesn't apply on top of trunk. I extracted it out
> of openacc-gcc-8-branch, plus additional changes, and it depends on a
> number of other pending patches. Due to the many regions of code
> touched, there are a lot of "textual" conflicts when porting it to
> current trunk, but the "structure" will be the same.)
Seems rather expensive to me, especially with the dependence on
libbacktrace and the unconditional initialization of the profiling from the
library constructor. Could e.g. libbacktrace or some libgomp plugin that is
linked against libbacktrace be dlopened only when apps ask for this stuff?
OpenMP 5 has a profiling API too (OMPT), there the rough plan for when it
will be implemented is that libgomp as the library will implement only the
absolute required minimum and perhaps have a variant library that is a
replacement for libgomp if more detailed instrumentation is needed.
Jakub
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: OpenACC 2.5 Profiling Interface
2018-12-04 13:13 ` Jakub Jelinek
@ 2019-05-15 14:28 ` Thomas Schwinge
0 siblings, 0 replies; 23+ messages in thread
From: Thomas Schwinge @ 2019-05-15 14:28 UTC (permalink / raw)
To: Jakub Jelinek; +Cc: gcc-patches
Hi Jakub!
On Tue, 4 Dec 2018 14:13:49 +0100, Jakub Jelinek <jakub@redhat.com> wrote:
> On Sun, Nov 11, 2018 at 10:31:42PM -0600, Thomas Schwinge wrote:
> > On Tue, 28 Feb 2017 18:43:36 +0100, I wrote:
> > > The 2.5 versions of the OpenACC standard added a new chapter "Profiling
> > > Interface".
> >
> > I'd like to get that into trunk. It's not yet complete (that is, doesn't
> > provide all the information specified), but it's very useful already, and
> > the missing pieces can later be added incrementally.
> >
> > Jakub, would you please especially review the non-OpenACC-specific
> > changes here, including the libgomp ABI changes?
> >
> > (Note that this patch doesn't apply on top of trunk. I extracted it out
> > of openacc-gcc-8-branch, plus additional changes, and it depends on a
> > number of other pending patches. Due to the many regions of code
> > touched, there are a lot of "textual" conflicts when porting it to
> > current trunk, but the "structure" will be the same.)
>
> Seems rather expensive to me, especially with the dependence on
> libbacktrace and the unconditional initialization of the profiling from the
> library constructor. Could e.g. libbacktrace or some libgomp plugin that is
> linked against libbacktrace be dlopened only when apps ask for this stuff?
Thanks, that seems plausible, and I'm looking into that.
> OpenMP 5 has a profiling API too (OMPT)
(... which I'm not familiar with...)
> there the rough plan for when it
> will be implemented is that libgomp as the library will implement only the
> absolute required minimum and perhaps have a variant library that is a
> replacement for libgomp if more detailed instrumentation is needed.
The "problem" with the OpenACC Profiling Interface is that the user can
enable the callbacks etc. anytime dynamically at run time. So, as I
understand, that rules out the "variant library" approach?
Grüße
Thomas
^ permalink raw reply [flat|nested] 23+ messages in thread
* OpenACC Profiling Interface: 'acc_register_library' (was: OpenACC 2.5 Profiling Interface)
2018-11-12 4:32 ` OpenACC 2.5 Profiling Interface Thomas Schwinge
2018-12-04 13:13 ` Jakub Jelinek
@ 2019-05-16 15:22 ` Thomas Schwinge
2019-05-16 15:54 ` Jakub Jelinek
1 sibling, 1 reply; 23+ messages in thread
From: Thomas Schwinge @ 2019-05-16 15:22 UTC (permalink / raw)
To: Jakub Jelinek; +Cc: gcc-patches
Hi Jakub!
On Sun, 11 Nov 2018 22:31:42 -0600, I wrote:
> On Tue, 28 Feb 2017 18:43:36 +0100, I wrote:
> > The 2.5 versions of the OpenACC standard added a new chapter "Profiling
> > Interface".
>
> I'd like to get that into trunk. It's not yet complete (that is, doesn't
> provide all the information specified), but it's very useful already, and
> the missing pieces can later be added incrementally.
>
> Jakub, would you please especially review the non-OpenACC-specific
> changes here, including the libgomp ABI changes?
Given a baseline that I've not yet posted ;-) would you please anyway
have a look at the following changes? Is it OK to add/handle the
'acc_register_library' symbol in this way? The idea behind that one is
that you dynamically (including via 'LD_PRELOAD') link your code against
a "library" providing an implementation of 'acc_register_library', or
even define it in your user code (see the test case below), and then upon
initialization, "The OpenACC runtime will invoke 'acc_register_library',
passing [...]".
As far as I can tell, it was never a concern (by us internally as well as
that nobody external ever complained) that 'acc_*' and 'GOACC_*' symbols
are visible when building with '-fopenmp' but (default) '-fno-openacc',
and vice versa, 'omp_*' and 'GOMP_*' symbols are visible when building
with '-fopenacc' but (default) '-fno-openmp'. But,
'acc_register_library' is special in that the runtime (libgomp) will
unconditionally call it, also for '-fopenmp' but (default)
'-fno-openacc'. So, when OpenMP user code happens to contain an
(unrelated) 'acc_register_library' symbol, strange things will happen.
OpenACC states that "Typically, the OpenACC runtime will include a _weak_
definition of 'acc_register_library', which does nothing and which will
be called when there is no tools library". I'm not sure if that's "weak"
specifically in the ELF linking sense, or just generally "weak"
semantics. But it seemed easy enough to just provide a regular symbol in
its own '*.o' file, to be overridden in both the dynamic and static
linking cases, so that's what I've done. Any comments to that aspect?
--- libgomp/Makefile.am
+++ libgomp/Makefile.am
@@ -66,7 +66,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c error.c \
splay-tree.c libgomp-plugin.c oacc-parallel.c oacc-host.c oacc-init.c \
oacc-mem.c oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
affinity-fmt.c teams.c \
- oacc-profiling.c
+ oacc-profiling.c oacc-profiling-acc_register_library.c
include $(top_srcdir)/plugin/Makefrag.am
--- libgomp/acc_prof.h
+++ libgomp/acc_prof.h
@@ -235,6 +235,9 @@ extern void acc_prof_unregister (acc_event_t, acc_prof_callback, acc_register_t)
typedef void (*acc_query_fn) ();
typedef acc_query_fn (*acc_prof_lookup_func) (const char *);
extern acc_query_fn acc_prof_lookup (const char *) __GOACC_NOTHROW;
+/* Don't tag 'acc_register_library' as '__GOACC_NOTHROW': this function can be
+ overridden by the application, and must be expected to do anything. */
+extern void acc_register_library (acc_prof_reg, acc_prof_reg, acc_prof_lookup_func);
#ifdef __cplusplus
--- libgomp/libgomp.map
+++ libgomp/libgomp.map
@@ -469,6 +469,7 @@ OACC_2.5 {
acc_prof_lookup;
acc_prof_register;
acc_prof_unregister;
+ acc_register_library;
acc_update_device_async;
acc_update_device_async_32_h_;
acc_update_device_async_64_h_;
--- /dev/null
+++ libgomp/oacc-profiling-acc_register_library.c
@@ -0,0 +1,40 @@
+/* OpenACC Profiling Interface: stub 'acc_register_library' function
+[...]
+
+#include "libgomp.h"
+#include "acc_prof.h"
+
+/* This is in its own file so that this function definition can be overridden
+ when linking statically. */
+
+void
+acc_register_library (acc_prof_reg reg, acc_prof_reg unreg,
+ acc_prof_lookup_func lookup)
+{
+ gomp_debug (0, "dummy %s\n", __FUNCTION__);
+}
--- libgomp/oacc-profiling.c
+++ libgomp/oacc-profiling.c
@@ -107,6 +107,12 @@ goacc_profiling_initialize (void)
/* ..., but profiling is still disabled. */
__atomic_store_n (&goacc_prof_enabled, false, MEMMODEL_RELAXED);
+ /* We are to invoke an external acc_register_library routine, defaulting to
+ our stub oacc-profiling-acc_register_library.c:acc_register_library
+ implementation. */
+ gomp_debug (0, "%s: calling acc_register_library\n", __FUNCTION__);
+ acc_register_library (acc_prof_register, acc_prof_unregister,
+ acc_prof_lookup);
#ifdef PLUGIN_SUPPORT
char *acc_proflibs = secure_getenv ("ACC_PROFLIB");
while (acc_proflibs != NULL && acc_proflibs[0] != '\0')
@@ -139,16 +145,24 @@ goacc_profiling_initialize (void)
void *dl_handle = dlopen (acc_proflib, RTLD_LAZY);
if (dl_handle != NULL)
{
- extern void acc_register_library (acc_prof_reg, acc_prof_reg,
- acc_prof_lookup_func);
typeof (&acc_register_library) a_r_l
= dlsym (dl_handle, "acc_register_library");
if (a_r_l == NULL)
goto dl_fail;
- gomp_debug (0, " %s: calling %s:acc_register_library\n",
- __FUNCTION__, acc_proflib);
- a_r_l (acc_prof_register, acc_prof_unregister,
- acc_prof_lookup);
+ /* Avoid duplicate registration, for example if the same shared
+ library is specified in LD_PRELOAD and ACC_PROFLIB -- which,
+ for example, TAU 2.26 does when using 'tau_exec -openacc'. */
+ if (a_r_l == acc_register_library)
+ gomp_debug (0, " %s: skipping duplicate"
+ " %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ else
+ {
+ gomp_debug (0, " %s: calling %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ a_r_l (acc_prof_register, acc_prof_unregister,
+ acc_prof_lookup);
+ }
}
else
{
--- libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
+++ libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
@@ -102,7 +102,7 @@ static void cb_compute_construct_end_3 (acc_prof_info *prof_info, acc_event_info
static acc_prof_reg reg;
static acc_prof_reg unreg;
static acc_prof_lookup_func lookup;
-static void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
{
DEBUG_printf ("%s\n", __FUNCTION__);
@@ -114,8 +114,6 @@ static void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_pr
int main()
{
- acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
-
STATE_OP (state, = 0);
reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
[...]
Grüße
Thomas
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: OpenACC Profiling Interface: 'acc_register_library' (was: OpenACC 2.5 Profiling Interface)
2019-05-16 15:22 ` OpenACC Profiling Interface: 'acc_register_library' (was: OpenACC 2.5 Profiling Interface) Thomas Schwinge
@ 2019-05-16 15:54 ` Jakub Jelinek
2019-05-16 19:43 ` OpenACC Profiling Interface: 'acc_register_library' Thomas Schwinge
0 siblings, 1 reply; 23+ messages in thread
From: Jakub Jelinek @ 2019-05-16 15:54 UTC (permalink / raw)
To: Thomas Schwinge; +Cc: gcc-patches
On Thu, May 16, 2019 at 05:21:56PM +0200, Thomas Schwinge wrote:
> > Jakub, would you please especially review the non-OpenACC-specific
> > changes here, including the libgomp ABI changes?
>
> Given a baseline that I've not yet posted ;-) would you please anyway
> have a look at the following changes? Is it OK to add/handle the
> 'acc_register_library' symbol in this way? The idea behind that one is
> that you dynamically (including via 'LD_PRELOAD') link your code against
> a "library" providing an implementation of 'acc_register_library', or
> even define it in your user code (see the test case below), and then upon
> initialization, "The OpenACC runtime will invoke 'acc_register_library',
> passing [...]".
Ugh, it is a mess (but then, seems OMPT has the same mess with
ompt_start_tool symbol).
It is nasty to call acc_register_library from initialization of the OpenMP
library, similarly to nastyness of calling ompt_start_tool from
initialization of the OpenACC library, neither of those symbols is reserved
to the implementation generally.
Can't we not do anything for -fopenacc or -fopenmp and have
-fopenacc-profile or -fopenmpt options that would link in another shared
library which just provides that symbol and calls it from its
initialization? The dummy implementation would be __attribute__((weak))
and would dlsym (RTLD_NEXT, "...") and call that if it returns non-NULL,
so even if that library happens to be linked before whatever library
implements the user symbol.
Looking at what libomp does for ompt_start_tool, for Darwin they don't use
a weak symbol and instead just dlsym(RTLD_DEFAULT, "...") in the
library ctor, for Linux they have a weak definition that does dlsym
(RTLD_NEXT, "...") and for Windows use something yet different.
> --- libgomp/libgomp.map
> +++ libgomp/libgomp.map
> @@ -469,6 +469,7 @@ OACC_2.5 {
> acc_prof_lookup;
> acc_prof_register;
> acc_prof_unregister;
> + acc_register_library;
> acc_update_device_async;
> acc_update_device_async_32_h_;
> acc_update_device_async_64_h_;
You certainly never want to add something to a symbol version
that has been shipped in a release compiler already.
Jakub
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: OpenACC Profiling Interface: 'acc_register_library'
2019-05-16 15:54 ` Jakub Jelinek
@ 2019-05-16 19:43 ` Thomas Schwinge
2019-05-17 19:19 ` [committed] OpenACC Profiling Interface (incomplete) Thomas Schwinge
0 siblings, 1 reply; 23+ messages in thread
From: Thomas Schwinge @ 2019-05-16 19:43 UTC (permalink / raw)
To: Jakub Jelinek; +Cc: gcc-patches
Hi Jakub!
On Thu, 16 May 2019 17:54:23 +0200, Jakub Jelinek <jakub@redhat.com> wrote:
> On Thu, May 16, 2019 at 05:21:56PM +0200, Thomas Schwinge wrote:
> > > Jakub, would you please especially review the non-OpenACC-specific
> > > changes here, including the libgomp ABI changes?
> >
> > Given a baseline that I've not yet posted ;-) would you please anyway
> > have a look at the following changes? Is it OK to add/handle the
> > 'acc_register_library' symbol in this way? The idea behind that one is
> > that you dynamically (including via 'LD_PRELOAD') link your code against
> > a "library" providing an implementation of 'acc_register_library', or
> > even define it in your user code (see the test case below), and then upon
> > initialization, "The OpenACC runtime will invoke 'acc_register_library',
> > passing [...]".
>
> Ugh, it is a mess
;-P Hah, I was very sure that you'd say something like that!
> (but then, seems OMPT has the same mess with
> ompt_start_tool symbol).
..., but at least it's not OpenACC alone. ;-)
> It is nasty to call acc_register_library from initialization of the OpenMP
> library, similarly to nastyness of calling ompt_start_tool from
> initialization of the OpenACC library, neither of those symbols is reserved
> to the implementation generally.
> Can't we not do anything for -fopenacc or -fopenmp and have
> -fopenacc-profile or -fopenmpt options that would link in another shared
> library which just provides that symbol and calls it from its
> initialization?
At least for OpenACC, I don't think we'll want an additional/separate
command-line flag, but yes, a separate library that only gets linked in
for explicit '-fopenacc' would've been my next idea, too. This should be
easy to do GCC spec-wise, and also in the libgomp Automake build system.
> The dummy implementation would be __attribute__((weak))
> and would dlsym (RTLD_NEXT, "...") and call that if it returns non-NULL,
> so even if that library happens to be linked before whatever library
> implements the user symbol.
> Looking at what libomp does for ompt_start_tool, for Darwin they don't use
> a weak symbol and instead just dlsym(RTLD_DEFAULT, "...") in the
> library ctor, for Linux they have a weak definition that does dlsym
> (RTLD_NEXT, "...") and for Windows use something yet different.
Will that work for the case of static linking, though? OpenACC for
"Statically-Linked Library Initialization" describes that "A tools
library can be compiled and linked directly into the application. If the
library provides an external routine 'acc_register_library' [...], the
runtime will invoke that routine to initialize the library".
If the proposed scheme won't work, we'll probably have to make the
runtime (libgomp) aware whether an explicit compile-time '-fopenacc' flag
had been specified, and only if yes, at run-time then invoke
'acc_register_library'?
Anyway, I'll defer the actual implementation for later.
But I'll still now include in the commit that I'm preparing the
'acc_register_library' prototype in <openacc.h>, and also its symbol
version, because these things apply no matter whether we now call that
function from 'goacc_profiling_initialize' or not.
Does the 'acc_register_library' symbol version need to be backed by a
(stub) function definition? It builds without, but it doesn't appear in
'readelf --dyn-syms x86_64-pc-linux-gnu/libgomp/.libs/libgomp.so'; is
that OK or not?
> > --- libgomp/libgomp.map
> > +++ libgomp/libgomp.map
> > @@ -469,6 +469,7 @@ OACC_2.5 {
> > acc_prof_lookup;
> > acc_prof_register;
> > acc_prof_unregister;
> > + acc_register_library;
> > acc_update_device_async;
> > acc_update_device_async_32_h_;
> > acc_update_device_async_64_h_;
>
> You certainly never want to add something to a symbol version
> that has been shipped in a release compiler already.
Thanks, fixed.
Grüße
Thomas
^ permalink raw reply [flat|nested] 23+ messages in thread
* [committed] OpenACC Profiling Interface (incomplete)
2019-05-16 19:43 ` OpenACC Profiling Interface: 'acc_register_library' Thomas Schwinge
@ 2019-05-17 19:19 ` Thomas Schwinge
2019-06-17 13:27 ` [PATCH, og9] Port OpenACC profiling interface to OG9 Kwok Cheung Yeung
2021-07-27 9:33 ` [committed] OpenACC Profiling Interface (incomplete) Thomas Schwinge
0 siblings, 2 replies; 23+ messages in thread
From: Thomas Schwinge @ 2019-05-17 19:19 UTC (permalink / raw)
To: gcc-patches; +Cc: Jakub Jelinek
[-- Attachment #1: Type: text/plain, Size: 1341 bytes --]
Hi!
On Thu, 16 May 2019 21:43:47 +0200, I wrote:
> On Thu, 16 May 2019 17:54:23 +0200, Jakub Jelinek <jakub@redhat.com> wrote:
> > On Thu, May 16, 2019 at 05:21:56PM +0200, Thomas Schwinge wrote:
> > > > Jakub, would you please especially review the non-OpenACC-specific
> > > > changes here, including the libgomp ABI changes?
> > >
> > > Given a baseline that I've not yet posted ;-) [...]
> > > "The OpenACC runtime will invoke 'acc_register_library',
> Will [...] work for the case of static linking, though?
I think I have an idea, but:
> Anyway, I'll defer the actual implementation for later.
> But I'll still now include in the commit that I'm preparing the
> 'acc_register_library' prototype in <openacc.h>, and also its symbol
> version, because these things apply no matter whether we now call that
> function from 'goacc_profiling_initialize' or not.
>
> Does the 'acc_register_library' symbol version need to be backed by a
> (stub) function definition? It builds without, but it doesn't appear in
> 'readelf --dyn-syms x86_64-pc-linux-gnu/libgomp/.libs/libgomp.so'; is
> that OK or not?
I'm simply including a stub function, which can then be replaced, later
on.
Committed to trunk in r271346 "OpenACC Profiling Interface (incomplete)",
see attached.
Grüße
Thomas
[-- Attachment #2: 0001-OpenACC-Profiling-Interface-incomplete.trunk.patch --]
[-- Type: text/x-diff, Size: 180676 bytes --]
From 5feffd51c51c0ca461c3819db9ff364ed2eec1c5 Mon Sep 17 00:00:00 2001
From: tschwinge <tschwinge@138bc75d-0d04-0410-961f-82ee72b054a4>
Date: Fri, 17 May 2019 19:13:36 +0000
Subject: [PATCH] OpenACC Profiling Interface (incomplete)
libgomp/
* acc_prof.h: New file.
* oacc-profiling.c: Likewise.
* Makefile.am (nodist_libsubinclude_HEADERS, libgomp_la_SOURCES):
Add these, respectively.
* Makefile.in: Regenerate.
* env.c (initialize_env): Call goacc_profiling_initialize.
* oacc-plugin.c (GOMP_PLUGIN_goacc_thread)
(GOMP_PLUGIN_goacc_profiling_dispatch): New functions.
* oacc-plugin.h (GOMP_PLUGIN_goacc_thread)
(GOMP_PLUGIN_goacc_profiling_dispatch): Declare.
* libgomp.map (OACC_2.5.1): Add acc_prof_lookup,
acc_prof_register, acc_prof_unregister, and acc_register_library.
(GOMP_PLUGIN_1.3): Add GOMP_PLUGIN_goacc_profiling_dispatch, and
GOMP_PLUGIN_goacc_thread.
* oacc-int.h (struct goacc_thread): Add prof_info, api_info,
prof_callbacks_enabled members.
(goacc_prof_enabled, goacc_profiling_initialize)
(_goacc_profiling_dispatch_p, _goacc_profiling_setup_p)
(goacc_profiling_dispatch): Declare.
(GOACC_PROF_ENABLED, GOACC_PROFILING_DISPATCH_P)
(GOACC_PROFILING_SETUP_P): Define.
* oacc-async.c (acc_async_test, acc_async_test_all, acc_wait)
(acc_wait_async, acc_wait_all, acc_wait_all_async): Update for
OpenACC Profiling Interface.
* oacc-cuda.c (acc_get_current_cuda_device)
(acc_get_current_cuda_context, acc_get_cuda_stream)
(acc_set_cuda_stream): Likewise.
* oacc-init.c (acc_init_1, goacc_attach_host_thread_to_device)
(acc_init, acc_set_device_type, acc_get_device_type)
(acc_get_device_num, goacc_lazy_initialize): Likewise.
* oacc-mem.c (acc_malloc, acc_free, memcpy_tofrom_device)
(acc_deviceptr, acc_hostptr, acc_is_present, acc_map_data)
(acc_unmap_data, present_create_copy, delete_copyout)
(update_dev_host): Likewise.
* oacc-parallel.c (GOACC_parallel_keyed, GOACC_data_start)
(GOACC_data_end, GOACC_enter_exit_data, GOACC_update, GOACC_wait):
Likewise.
* plugin/plugin-nvptx.c (nvptx_exec, nvptx_alloc, nvptx_free)
(GOMP_OFFLOAD_openacc_exec, GOMP_OFFLOAD_openacc_async_exec):
Likewise.
* libgomp.texi: Update.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c: New
file.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c: Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c:
Likewise.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@271346 138bc75d-0d04-0410-961f-82ee72b054a4
---
libgomp/ChangeLog | 55 ++
libgomp/Makefile.am | 4 +-
libgomp/Makefile.in | 7 +-
libgomp/acc_prof.h | 252 ++++++
libgomp/env.c | 2 +
libgomp/libgomp.map | 14 +
libgomp/libgomp.texi | 412 ++++++++++
libgomp/oacc-async.c | 121 ++-
libgomp/oacc-cuda.c | 81 +-
libgomp/oacc-init.c | 124 ++-
libgomp/oacc-int.h | 29 +
libgomp/oacc-mem.c | 113 ++-
libgomp/oacc-parallel.c | 460 ++++++++++-
libgomp/oacc-plugin.c | 17 +
libgomp/oacc-plugin.h | 7 +
libgomp/oacc-profiling.c | 662 ++++++++++++++++
libgomp/plugin/plugin-nvptx.c | 196 ++++-
.../acc_prof-dispatch-1.c | 353 +++++++++
.../acc_prof-init-1.c | 316 ++++++++
.../acc_prof-kernels-1.c | 229 ++++++
.../acc_prof-parallel-1.c | 719 ++++++++++++++++++
.../acc_prof-valid_bytes-1.c | 226 ++++++
.../acc_prof-version-1.c | 76 ++
23 files changed, 4400 insertions(+), 75 deletions(-)
create mode 100644 libgomp/acc_prof.h
create mode 100644 libgomp/oacc-profiling.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog
index a16d5244f54e..e0a128f948f7 100644
--- a/libgomp/ChangeLog
+++ b/libgomp/ChangeLog
@@ -1,3 +1,58 @@
+2019-05-17 Thomas Schwinge <thomas@codesourcery.com>
+
+ * acc_prof.h: New file.
+ * oacc-profiling.c: Likewise.
+ * Makefile.am (nodist_libsubinclude_HEADERS, libgomp_la_SOURCES):
+ Add these, respectively.
+ * Makefile.in: Regenerate.
+ * env.c (initialize_env): Call goacc_profiling_initialize.
+ * oacc-plugin.c (GOMP_PLUGIN_goacc_thread)
+ (GOMP_PLUGIN_goacc_profiling_dispatch): New functions.
+ * oacc-plugin.h (GOMP_PLUGIN_goacc_thread)
+ (GOMP_PLUGIN_goacc_profiling_dispatch): Declare.
+ * libgomp.map (OACC_2.5.1): Add acc_prof_lookup,
+ acc_prof_register, acc_prof_unregister, and acc_register_library.
+ (GOMP_PLUGIN_1.3): Add GOMP_PLUGIN_goacc_profiling_dispatch, and
+ GOMP_PLUGIN_goacc_thread.
+ * oacc-int.h (struct goacc_thread): Add prof_info, api_info,
+ prof_callbacks_enabled members.
+ (goacc_prof_enabled, goacc_profiling_initialize)
+ (_goacc_profiling_dispatch_p, _goacc_profiling_setup_p)
+ (goacc_profiling_dispatch): Declare.
+ (GOACC_PROF_ENABLED, GOACC_PROFILING_DISPATCH_P)
+ (GOACC_PROFILING_SETUP_P): Define.
+ * oacc-async.c (acc_async_test, acc_async_test_all, acc_wait)
+ (acc_wait_async, acc_wait_all, acc_wait_all_async): Update for
+ OpenACC Profiling Interface.
+ * oacc-cuda.c (acc_get_current_cuda_device)
+ (acc_get_current_cuda_context, acc_get_cuda_stream)
+ (acc_set_cuda_stream): Likewise.
+ * oacc-init.c (acc_init_1, goacc_attach_host_thread_to_device)
+ (acc_init, acc_set_device_type, acc_get_device_type)
+ (acc_get_device_num, goacc_lazy_initialize): Likewise.
+ * oacc-mem.c (acc_malloc, acc_free, memcpy_tofrom_device)
+ (acc_deviceptr, acc_hostptr, acc_is_present, acc_map_data)
+ (acc_unmap_data, present_create_copy, delete_copyout)
+ (update_dev_host): Likewise.
+ * oacc-parallel.c (GOACC_parallel_keyed, GOACC_data_start)
+ (GOACC_data_end, GOACC_enter_exit_data, GOACC_update, GOACC_wait):
+ Likewise.
+ * plugin/plugin-nvptx.c (nvptx_exec, nvptx_alloc, nvptx_free)
+ (GOMP_OFFLOAD_openacc_exec, GOMP_OFFLOAD_openacc_async_exec):
+ Likewise.
+ * libgomp.texi: Update.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c: New
+ file.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c: Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c:
+ Likewise.
+
2019-05-13 Chung-Lin Tang <cltang@codesourcery.com>
* libgomp-plugin.h (struct goacc_asyncqueue): Declare.
diff --git a/libgomp/Makefile.am b/libgomp/Makefile.am
index 062fded0805a..7d36343a4be1 100644
--- a/libgomp/Makefile.am
+++ b/libgomp/Makefile.am
@@ -65,7 +65,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c error.c \
proc.c sem.c bar.c ptrlock.c time.c fortran.c affinity.c target.c \
splay-tree.c libgomp-plugin.c oacc-parallel.c oacc-host.c oacc-init.c \
oacc-mem.c oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
- affinity-fmt.c teams.c
+ affinity-fmt.c teams.c oacc-profiling.c
include $(top_srcdir)/plugin/Makefrag.am
@@ -74,7 +74,7 @@ libgomp_la_SOURCES += openacc.f90
endif
nodist_noinst_HEADERS = libgomp_f.h
-nodist_libsubinclude_HEADERS = omp.h openacc.h
+nodist_libsubinclude_HEADERS = omp.h openacc.h acc_prof.h
if USE_FORTRAN
nodist_finclude_HEADERS = omp_lib.h omp_lib.f90 omp_lib.mod omp_lib_kinds.mod \
openacc_lib.h openacc.f90 openacc.mod openacc_kinds.mod
diff --git a/libgomp/Makefile.in b/libgomp/Makefile.in
index c7e63f120fdb..1e2fa89f3af8 100644
--- a/libgomp/Makefile.in
+++ b/libgomp/Makefile.in
@@ -217,7 +217,7 @@ am_libgomp_la_OBJECTS = alloc.lo atomic.lo barrier.lo critical.lo \
target.lo splay-tree.lo libgomp-plugin.lo oacc-parallel.lo \
oacc-host.lo oacc-init.lo oacc-mem.lo oacc-async.lo \
oacc-plugin.lo oacc-cuda.lo priority_queue.lo affinity-fmt.lo \
- teams.lo $(am__objects_1)
+ teams.lo oacc-profiling.lo $(am__objects_1)
libgomp_la_OBJECTS = $(am_libgomp_la_OBJECTS)
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
@@ -551,7 +551,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c \
affinity.c target.c splay-tree.c libgomp-plugin.c \
oacc-parallel.c oacc-host.c oacc-init.c oacc-mem.c \
oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
- affinity-fmt.c teams.c $(am__append_3)
+ affinity-fmt.c teams.c oacc-profiling.c $(am__append_3)
# Nvidia PTX OpenACC plugin.
@PLUGIN_NVPTX_TRUE@libgomp_plugin_nvptx_version_info = -version-info $(libtool_VERSION)
@@ -575,7 +575,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c \
@PLUGIN_HSA_TRUE@libgomp_plugin_hsa_la_LIBADD = libgomp.la $(PLUGIN_HSA_LIBS)
@PLUGIN_HSA_TRUE@libgomp_plugin_hsa_la_LIBTOOLFLAGS = --tag=disable-static
nodist_noinst_HEADERS = libgomp_f.h
-nodist_libsubinclude_HEADERS = omp.h openacc.h
+nodist_libsubinclude_HEADERS = omp.h openacc.h acc_prof.h
@USE_FORTRAN_TRUE@nodist_finclude_HEADERS = omp_lib.h omp_lib.f90 omp_lib.mod omp_lib_kinds.mod \
@USE_FORTRAN_TRUE@ openacc_lib.h openacc.f90 openacc.mod openacc_kinds.mod
@@ -753,6 +753,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-mem.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-parallel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-plugin.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-profiling.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ordered.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/parallel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/priority_queue.Plo@am__quote@
diff --git a/libgomp/acc_prof.h b/libgomp/acc_prof.h
new file mode 100644
index 000000000000..c7a2197d11a9
--- /dev/null
+++ b/libgomp/acc_prof.h
@@ -0,0 +1,252 @@
+/* OpenACC Profiling Interface
+
+ Copyright (C) 2019 Free Software Foundation, Inc.
+
+ Contributed by Mentor, a Siemens Business.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+#ifndef _ACC_PROF_H
+#define _ACC_PROF_H 1
+
+
+/* The OpenACC specification doesn't say so explicitly, but as its Profiling
+ Interface explicitly makes use of, for example, <openacc.h>'s
+ 'acc_device_t', we supposedly are to '#include' that file here. */
+
+#include <openacc.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Events. */
+
+typedef enum acc_event_t
+{
+ acc_ev_none = 0,
+ acc_ev_device_init_start,
+ acc_ev_device_init_end,
+ acc_ev_device_shutdown_start,
+ acc_ev_device_shutdown_end,
+ acc_ev_runtime_shutdown,
+ acc_ev_create,
+ acc_ev_delete,
+ acc_ev_alloc,
+ acc_ev_free,
+ acc_ev_enter_data_start,
+ acc_ev_enter_data_end,
+ acc_ev_exit_data_start,
+ acc_ev_exit_data_end,
+ acc_ev_update_start,
+ acc_ev_update_end,
+ acc_ev_compute_construct_start,
+ acc_ev_compute_construct_end,
+ acc_ev_enqueue_launch_start,
+ acc_ev_enqueue_launch_end,
+ acc_ev_enqueue_upload_start,
+ acc_ev_enqueue_upload_end,
+ acc_ev_enqueue_download_start,
+ acc_ev_enqueue_download_end,
+ acc_ev_wait_start,
+ acc_ev_wait_end,
+ acc_ev_last
+} acc_event_t;
+
+
+/* Callbacks Signature. */
+
+/* "The datatype 'ssize_t' means a signed 32-bit integer for a 32-bit binary
+ and a 64-bit integer for a 64-bit binary". */
+typedef signed long int _acc_prof_ssize_t;
+/* "The datatype 'size_t' means an unsigned 32-bit integer for a 32-bit binary
+ and a 64-bit integer for a 64-bit binary". */
+typedef unsigned long int _acc_prof_size_t;
+/* "The datatype 'int' means a 32-bit integer for both 32-bit and 64-bit
+ binaries". */
+typedef int _acc_prof_int_t;
+
+/* Internal helpers: a struct's 'valid_bytes' may be less than its 'sizeof'. */
+#define _ACC_PROF_VALID_BYTES_STRUCT(_struct, _lastfield, _valid_bytes_lastfield) \
+ offsetof (_struct, _lastfield) + (_valid_bytes_lastfield)
+#if 0 /* Untested. */
+#define _ACC_PROF_VALID_BYTES_TYPE_N(_type, _n, _valid_bytes_type) \
+ ((_n - 1) * sizeof (_type) + (_valid_bytes_type))
+#endif
+#define _ACC_PROF_VALID_BYTES_BASICTYPE(_basictype) \
+ (sizeof (_basictype))
+
+typedef struct acc_prof_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ _acc_prof_int_t version;
+ acc_device_t device_type;
+ _acc_prof_int_t device_number;
+ _acc_prof_int_t thread_id;
+ _acc_prof_ssize_t async;
+ _acc_prof_ssize_t async_queue;
+ const char *src_file;
+ const char *func_name;
+ _acc_prof_int_t line_no, end_line_no;
+ _acc_prof_int_t func_line_no, func_end_line_no;
+#define _ACC_PROF_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_prof_info, func_end_line_no, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_int_t))
+} acc_prof_info;
+
+/* We implement the OpenACC 2.6 Profiling Interface. */
+
+#define _ACC_PROF_INFO_VERSION 201711
+
+typedef enum acc_construct_t
+{
+ acc_construct_parallel = 0,
+ acc_construct_kernels,
+ acc_construct_loop,
+ acc_construct_data,
+ acc_construct_enter_data,
+ acc_construct_exit_data,
+ acc_construct_host_data,
+ acc_construct_atomic,
+ acc_construct_declare,
+ acc_construct_init,
+ acc_construct_shutdown,
+ acc_construct_set,
+ acc_construct_update,
+ acc_construct_routine,
+ acc_construct_wait,
+ acc_construct_runtime_api,
+ acc_construct_serial
+} acc_construct_t;
+
+typedef struct acc_data_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ const char *var_name;
+ _acc_prof_size_t bytes;
+ const void *host_ptr;
+ const void *device_ptr;
+#define _ACC_DATA_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_data_event_info, device_ptr, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_data_event_info;
+
+typedef struct acc_launch_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ const char *kernel_name;
+ _acc_prof_size_t num_gangs, num_workers, vector_length;
+#define _ACC_LAUNCH_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_launch_event_info, vector_length, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_size_t))
+} acc_launch_event_info;
+
+typedef struct acc_other_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+#define _ACC_OTHER_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_other_event_info, tool_info, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_other_event_info;
+
+typedef union acc_event_info
+{
+ acc_event_t event_type;
+ acc_data_event_info data_event;
+ acc_launch_event_info launch_event;
+ acc_other_event_info other_event;
+} acc_event_info;
+
+typedef enum acc_device_api
+{
+ acc_device_api_none = 0,
+ acc_device_api_cuda,
+ acc_device_api_opencl,
+ acc_device_api_coi,
+ acc_device_api_other
+} acc_device_api;
+
+typedef struct acc_api_info
+{
+ acc_device_api device_api;
+ _acc_prof_int_t valid_bytes;
+ acc_device_t device_type;
+ _acc_prof_int_t vendor;
+ const void *device_handle;
+ const void *context_handle;
+ const void *async_handle;
+#define _ACC_API_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_api_info, async_handle, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_api_info;
+
+/* Don't tag 'acc_prof_callback' as '__GOACC_NOTHROW': these functions are
+ provided by user code, and must be expected to do anything. */
+typedef void (*acc_prof_callback) (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+
+
+/* Loading the Library. */
+
+typedef enum acc_register_t
+{
+ acc_reg = 0,
+ acc_toggle = 1,
+ acc_toggle_per_thread = 2
+} acc_register_t;
+
+typedef void (*acc_prof_reg) (acc_event_t, acc_prof_callback, acc_register_t);
+extern void acc_prof_register (acc_event_t, acc_prof_callback,
+ acc_register_t) __GOACC_NOTHROW;
+extern void acc_prof_unregister (acc_event_t, acc_prof_callback,
+ acc_register_t) __GOACC_NOTHROW;
+typedef void (*acc_query_fn) ();
+typedef acc_query_fn (*acc_prof_lookup_func) (const char *);
+extern acc_query_fn acc_prof_lookup (const char *) __GOACC_NOTHROW;
+/* Don't tag 'acc_register_library' as '__GOACC_NOTHROW': this function can be
+ overridden by user code, and must be expected to do anything. */
+extern void acc_register_library (acc_prof_reg, acc_prof_reg,
+ acc_prof_lookup_func);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* _ACC_PROF_H */
diff --git a/libgomp/env.c b/libgomp/env.c
index 7937fbb056a0..29d9f58cba3a 100644
--- a/libgomp/env.c
+++ b/libgomp/env.c
@@ -1425,5 +1425,7 @@ initialize_env (void)
parse_gomp_openacc_dim ();
goacc_runtime_initialize ();
+
+ goacc_profiling_initialize ();
}
#endif /* LIBGOMP_OFFLOADED_ONLY */
diff --git a/libgomp/libgomp.map b/libgomp/libgomp.map
index d8e2fd1818b9..c79430f8d8d1 100644
--- a/libgomp/libgomp.map
+++ b/libgomp/libgomp.map
@@ -476,6 +476,14 @@ OACC_2.5 {
acc_update_self_async_array_h_;
} OACC_2.0.1;
+OACC_2.5.1 {
+ global:
+ acc_prof_lookup;
+ acc_prof_register;
+ acc_prof_unregister;
+ acc_register_library;
+} OACC_2.5;
+
GOACC_2.0 {
global:
GOACC_data_end;
@@ -515,3 +523,9 @@ GOMP_PLUGIN_1.2 {
global:
GOMP_PLUGIN_acc_default_dim;
} GOMP_PLUGIN_1.1;
+
+GOMP_PLUGIN_1.3 {
+ global:
+ GOMP_PLUGIN_goacc_profiling_dispatch;
+ GOMP_PLUGIN_goacc_thread;
+} GOMP_PLUGIN_1.2;
diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi
index e2e384ae8b62..6db895f62726 100644
--- a/libgomp/libgomp.texi
+++ b/libgomp/libgomp.texi
@@ -111,6 +111,7 @@ changed to GNU Offloading and Multi Processing Runtime Library.
asynchronous operations.
* OpenACC Library Interoperability:: OpenACC library interoperability with the
NVIDIA CUBLAS library.
+* OpenACC Profiling Interface::
* The libgomp ABI:: Notes on the external ABI presented by libgomp.
* Reporting Bugs:: How to report bugs in the GNU Offloading and
Multi Processing Runtime Library.
@@ -1897,6 +1898,13 @@ API routines for target platforms.
* acc_get_current_cuda_context::Get CUDA context handle.
* acc_get_cuda_stream:: Get CUDA stream handle.
* acc_set_cuda_stream:: Set CUDA stream handle.
+
+API routines for the OpenACC Profiling Interface.
+
+* acc_prof_register:: Register callbacks.
+* acc_prof_unregister:: Unregister callbacks.
+* acc_prof_lookup:: Obtain inquiry functions.
+* acc_register_library:: Library registration.
@end menu
@@ -2823,6 +2831,90 @@ A.2.1.4.
+@node acc_prof_register
+@section @code{acc_prof_register} -- Register callbacks.
+@table @asis
+@item @emph{Description}:
+This function registers callbacks.
+
+@item @emph{C/C++}:
+@multitable @columnfractions .20 .80
+@item @emph{Prototype}: @tab @code{void acc_prof_register (acc_event_t, acc_prof_callback, acc_register_t);}
+@end multitable
+
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+5.3.
+@end table
+
+
+
+@node acc_prof_unregister
+@section @code{acc_prof_unregister} -- Unregister callbacks.
+@table @asis
+@item @emph{Description}:
+This function unregisters callbacks.
+
+@item @emph{C/C++}:
+@multitable @columnfractions .20 .80
+@item @emph{Prototype}: @tab @code{void acc_prof_unregister (acc_event_t, acc_prof_callback, acc_register_t);}
+@end multitable
+
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+5.3.
+@end table
+
+
+
+@node acc_prof_lookup
+@section @code{acc_prof_lookup} -- Obtain inquiry functions.
+@table @asis
+@item @emph{Description}:
+Function to obtain inquiry functions.
+
+@item @emph{C/C++}:
+@multitable @columnfractions .20 .80
+@item @emph{Prototype}: @tab @code{acc_query_fn acc_prof_lookup (const char *);}
+@end multitable
+
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+5.3.
+@end table
+
+
+
+@node acc_register_library
+@section @code{acc_register_library} -- Library registration.
+@table @asis
+@item @emph{Description}:
+Function for library registration.
+
+@item @emph{C/C++}:
+@multitable @columnfractions .20 .80
+@item @emph{Prototype}: @tab @code{void acc_register_library (acc_prof_reg, acc_prof_reg, acc_prof_lookup_func);}
+@end multitable
+
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}, @ref{ACC_PROFLIB}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+5.3.
+@end table
+
+
+
@c ---------------------------------------------------------------------
@c OpenACC Environment Variables
@c ---------------------------------------------------------------------
@@ -2832,11 +2924,14 @@ A.2.1.4.
The variables @env{ACC_DEVICE_TYPE} and @env{ACC_DEVICE_NUM}
are defined by section 4 of the OpenACC specification in version 2.0.
+The variable @env{ACC_PROFLIB}
+is defined by section 4 of the OpenACC specification in version 2.6.
The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
@menu
* ACC_DEVICE_TYPE::
* ACC_DEVICE_NUM::
+* ACC_PROFLIB::
* GCC_ACC_NOTIFY::
@end menu
@@ -2862,6 +2957,19 @@ The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
+@node ACC_PROFLIB
+@section @code{ACC_PROFLIB}
+@table @asis
+@item @emph{See also}:
+@ref{acc_register_library}, @ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+4.3.
+@end table
+
+
+
@node GCC_ACC_NOTIFY
@section @code{GCC_ACC_NOTIFY}
@table @asis
@@ -3077,6 +3185,310 @@ Application Programming Interface”, Version 2.0.}
+@c ---------------------------------------------------------------------
+@c OpenACC Profiling Interface
+@c ---------------------------------------------------------------------
+
+@node OpenACC Profiling Interface
+@chapter OpenACC Profiling Interface
+
+@section Implementation Status and Implementation-Defined Behavior
+
+We're implementing the OpenACC Profiling Interface as defined by the
+OpenACC 2.6 specification. We're clarifying some aspects here as
+@emph{implementation-defined behavior}, while they're still under
+discussion within the OpenACC Technical Committee.
+
+This implementation is tuned to keep the performance impact as low as
+possible for the (very common) case that the Profiling Interface is
+not enabled. This is relevant, as the Profiling Interface affects all
+the @emph{hot} code paths (in the target code, not in the offloaded
+code). Users of the OpenACC Profiling Interface can be expected to
+understand that performance will be impacted to some degree once the
+Profiling Interface has gotten enabled: for example, because of the
+@emph{runtime} (libgomp) calling into a third-party @emph{library} for
+every event that has been registered.
+
+We're not yet accounting for the fact that @cite{OpenACC events may
+occur during event processing}.
+
+We're not yet implementing initialization via a
+@code{acc_register_library} function that is either statically linked
+in, or dynamically via @env{LD_PRELOAD}.
+Initialization via @code{acc_register_library} functions dynamically
+loaded via the @env{ACC_PROFLIB} environment variable does work, as
+does directly calling @code{acc_prof_register},
+@code{acc_prof_unregister}, @code{acc_prof_lookup}.
+
+As currently there are no inquiry functions defined, calls to
+@code{acc_prof_lookup} will always return @code{NULL}.
+
+There aren't separate @emph{start}, @emph{stop} events defined for the
+event types @code{acc_ev_create}, @code{acc_ev_delete},
+@code{acc_ev_alloc}, @code{acc_ev_free}. It's not clear if these
+should be triggered before or after the actual device-specific call is
+made. We trigger them after.
+
+Remarks about data provided to callbacks:
+
+@table @asis
+
+@item @code{acc_prof_info.event_type}
+It's not clear if for @emph{nested} event callbacks (for example,
+@code{acc_ev_enqueue_launch_start} as part of a parent compute
+construct), this should be set for the nested event
+(@code{acc_ev_enqueue_launch_start}), or if the value of the parent
+construct should remain (@code{acc_ev_compute_construct_start}). In
+this implementation, the value will generally correspond to the
+innermost nested event type.
+
+@item @code{acc_prof_info.device_type}
+@itemize
+
+@item
+For @code{acc_ev_compute_construct_start}, and in presence of an
+@code{if} clause with @emph{false} argument, this will still refer to
+the offloading device type.
+It's not clear if that's the expected behavior.
+
+@item
+Complementary to the item before, for
+@code{acc_ev_compute_construct_end}, this is set to
+@code{acc_device_host} in presence of an @code{if} clause with
+@emph{false} argument.
+It's not clear if that's the expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.thread_id}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.async}
+@itemize
+
+@item
+Not yet implemented correctly for
+@code{acc_ev_compute_construct_start}.
+
+@item
+In a compute construct, for host-fallback
+execution/@code{acc_device_host} it will always be
+@code{acc_async_sync}.
+It's not clear if that's the expected behavior.
+
+@item
+For @code{acc_ev_device_init_start} and @code{acc_ev_device_init_end},
+it will always be @code{acc_async_sync}.
+It's not clear if that's the expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.async_queue}
+There is no @cite{limited number of asynchronous queues} in libgomp.
+This will always have the same value as @code{acc_prof_info.async}.
+
+@item @code{acc_prof_info.src_file}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_prof_info.func_name}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_prof_info.line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_event_info.event_type}, @code{acc_event_info.*.event_type}
+Relating to @code{acc_prof_info.event_type} discussed above, in this
+implementation, this will always be the same value as
+@code{acc_prof_info.event_type}.
+
+@item @code{acc_event_info.*.parent_construct}
+@itemize
+
+@item
+Will be @code{acc_construct_parallel} for all OpenACC compute
+constructs as well as many OpenACC Runtime API calls; should be the
+one matching the actual construct, or
+@code{acc_construct_runtime_api}, respectively.
+
+@item
+Will be @code{acc_construct_enter_data} or
+@code{acc_construct_exit_data} when processing variable mappings
+specified in OpenACC @emph{declare} directives; should be
+@code{acc_construct_declare}.
+
+@item
+For implicit @code{acc_ev_device_init_start},
+@code{acc_ev_device_init_end}, and explicit as well as implicit
+@code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start}, and
+@code{acc_ev_enqueue_download_end}, will be
+@code{acc_construct_parallel}; should reflect the real parent
+construct.
+
+@end itemize
+
+@item @code{acc_event_info.*.implicit}
+For @code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start}, and
+@code{acc_ev_enqueue_download_end}, this currently will be @code{1}
+also for explicit usage.
+
+@item @code{acc_event_info.data_event.var_name}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_event_info.data_event.host_ptr}
+For @code{acc_ev_alloc}, and @code{acc_ev_free}, this is always
+@code{NULL}.
+
+@item @code{typedef union acc_api_info}
+@dots{} as printed in @cite{5.2.3. Third Argument: API-Specific
+Information}. This should obviously be @code{typedef @emph{struct}
+acc_api_info}.
+
+@item @code{acc_api_info.device_api}
+Possibly not yet implemented correctly for
+@code{acc_ev_compute_construct_start},
+@code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}:
+will always be @code{acc_device_api_none} for these event types.
+For @code{acc_ev_enter_data_start}, it will be
+@code{acc_device_api_none} in some cases.
+
+@item @code{acc_api_info.device_type}
+Always the same as @code{acc_prof_info.device_type}.
+
+@item @code{acc_api_info.vendor}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_api_info.device_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.context_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.async_handle}
+Always @code{NULL}; not yet implemented.
+
+@end table
+
+Remarks about certain event types:
+
+@table @asis
+
+@item @code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}
+@itemize
+
+@item
+@c See 'DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT' in
+@c 'libgomp.oacc-c-c++-common/acc_prof-kernels-1.c',
+@c 'libgomp.oacc-c-c++-common/acc_prof-parallel-1.c'.
+Whan a compute construct triggers implicit
+@code{acc_ev_device_init_start} and @code{acc_ev_device_init_end}
+events, they currently aren't @emph{nested within} the corresponding
+@code{acc_ev_compute_construct_start} and
+@code{acc_ev_compute_construct_end}, but they're currently observed
+@emph{before} @code{acc_ev_compute_construct_start}.
+It's not clear what to do: the standard asks us provide a lot of
+details to the @code{acc_ev_compute_construct_start} callback, without
+(implicitly) initializing a device before?
+
+@item
+Callbacks for these event types will not be invoked for calls to the
+@code{acc_set_device_type} and @code{acc_set_device_num} functions.
+It's not clear if they should be.
+
+@end itemize
+
+@item @code{acc_ev_enter_data_start}, @code{acc_ev_enter_data_end}, @code{acc_ev_exit_data_start}, @code{acc_ev_exit_data_end}
+@itemize
+
+@item
+Callbacks for these event types will also be invoked for OpenACC
+@emph{host_data} constructs.
+It's not clear if they should be.
+
+@item
+Callbacks for these event types will also be invoked when processing
+variable mappings specified in OpenACC @emph{declare} directives.
+It's not clear if they should be.
+
+@end itemize
+
+@end table
+
+Callbacks for the following event types will be invoked, but dispatch
+and information provided therein has not yet been thoroughly reviewed:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@item @code{acc_ev_update_start}, @code{acc_ev_update_end}
+@item @code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end}
+@item @code{acc_ev_enqueue_download_start}, @code{acc_ev_enqueue_download_end}
+@end itemize
+
+During device initialization, and finalization, respectively,
+callbacks for the following event types will not yet be invoked:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@end itemize
+
+Callbacks for the following event types have not yet been implemented,
+so currently won't be invoked:
+
+@itemize
+@item @code{acc_ev_device_shutdown_start}, @code{acc_ev_device_shutdown_end}
+@item @code{acc_ev_runtime_shutdown}
+@item @code{acc_ev_create}, @code{acc_ev_delete}
+@item @code{acc_ev_wait_start}, @code{acc_ev_wait_end}
+@end itemize
+
+For the following runtime library functions, not all expected
+callbacks will be invoked (mostly concerning implicit device
+initialization):
+
+@itemize
+@item @code{acc_get_num_devices}
+@item @code{acc_set_device_type}
+@item @code{acc_get_device_type}
+@item @code{acc_set_device_num}
+@item @code{acc_get_device_num}
+@item @code{acc_init}
+@item @code{acc_shutdown}
+@end itemize
+
+Aside from implicit device initialization, for the following runtime
+library functions, no callbacks will be invoked for shared-memory
+offloading devices (it's not clear if they should be):
+
+@itemize
+@item @code{acc_malloc}
+@item @code{acc_free}
+@item @code{acc_copyin}, @code{acc_present_or_copyin}, @code{acc_copyin_async}
+@item @code{acc_create}, @code{acc_present_or_create}, @code{acc_create_async}
+@item @code{acc_copyout}, @code{acc_copyout_async}, @code{acc_copyout_finalize}, @code{acc_copyout_finalize_async}
+@item @code{acc_delete}, @code{acc_delete_async}, @code{acc_delete_finalize}, @code{acc_delete_finalize_async}
+@item @code{acc_update_device}, @code{acc_update_device_async}
+@item @code{acc_update_self}, @code{acc_update_self_async}
+@item @code{acc_map_data}, @code{acc_unmap_data}
+@item @code{acc_memcpy_to_device}, @code{acc_memcpy_to_device_async}
+@item @code{acc_memcpy_from_device}, @code{acc_memcpy_from_device_async}
+@end itemize
+
+
+
@c ---------------------------------------------------------------------
@c The libgomp ABI
@c ---------------------------------------------------------------------
diff --git a/libgomp/oacc-async.c b/libgomp/oacc-async.c
index 51bb676610c8..1760e8c90c63 100644
--- a/libgomp/oacc-async.c
+++ b/libgomp/oacc-async.c
@@ -43,17 +43,6 @@ get_goacc_thread (void)
return thr;
}
-static struct gomp_device_descr *
-get_goacc_thread_device (void)
-{
- struct goacc_thread *thr = goacc_thread ();
-
- if (!thr || !thr->dev)
- gomp_fatal ("no device active");
-
- return thr->dev;
-}
-
static int
validate_async_val (int async)
{
@@ -76,7 +65,10 @@ validate_async_val (int async)
/* Return the asyncqueue to be used for OpenACC async-argument ASYNC. This
might return NULL if no asyncqueue is to be used. Otherwise, if CREATE,
- create the asyncqueue if it doesn't exist yet. */
+ create the asyncqueue if it doesn't exist yet.
+
+ Unless CREATE, this will not generate any OpenACC Profiling Interface
+ events. */
attribute_hidden struct goacc_asyncqueue *
lookup_goacc_asyncqueue (struct goacc_thread *thr, bool create, int async)
@@ -152,8 +144,25 @@ acc_async_test (int async)
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
if (!aq)
return 1;
- else
- return thr->dev->openacc.async.test_func (aq);
+
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
+ int res = thr->dev->openacc.async.test_func (aq);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return res;
}
int
@@ -161,6 +170,10 @@ acc_async_test_all (void)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
int ret = 1;
gomp_mutex_lock (&thr->dev->openacc.async.lock);
for (goacc_aq_list l = thr->dev->openacc.async.active; l; l = l->next)
@@ -170,6 +183,13 @@ acc_async_test_all (void)
break;
}
gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return ret;
}
@@ -179,8 +199,26 @@ acc_wait (int async)
struct goacc_thread *thr = get_goacc_thread ();
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
- if (aq && !thr->dev->openacc.async.synchronize_func (aq))
+ if (!aq)
+ return;
+
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
+ if (!thr->dev->openacc.async.synchronize_func (aq))
gomp_fatal ("wait on %d failed", async);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
/* acc_async_wait is an OpenACC 1.0 compatibility name for acc_wait. */
@@ -205,10 +243,19 @@ acc_wait_async (int async1, int async2)
if (!aq1)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async2;
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq2 = lookup_goacc_asyncqueue (thr, true, async2);
/* An async queue is always synchronized with itself. */
if (aq1 == aq2)
- return;
+ goto out_prof;
if (aq2)
{
@@ -222,18 +269,35 @@ acc_wait_async (int async1, int async2)
if (!thr->dev->openacc.async.synchronize_func (aq1))
gomp_fatal ("wait on %d failed", async1);
}
+
+ out_prof:
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
acc_wait_all (void)
{
- struct gomp_device_descr *dev = get_goacc_thread_device ();
+ struct goacc_thread *thr = goacc_thread ();
+
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
bool ret = true;
- gomp_mutex_lock (&dev->openacc.async.lock);
- for (goacc_aq_list l = dev->openacc.async.active; l; l = l->next)
- ret &= dev->openacc.async.synchronize_func (l->aq);
- gomp_mutex_unlock (&dev->openacc.async.lock);
+ gomp_mutex_lock (&thr->dev->openacc.async.lock);
+ for (goacc_aq_list l = thr->dev->openacc.async.active; l; l = l->next)
+ ret &= thr->dev->openacc.async.synchronize_func (l->aq);
+ gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
if (!ret)
gomp_fatal ("wait all failed");
@@ -255,6 +319,15 @@ acc_wait_all_async (int async)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq waiting_queue = lookup_goacc_asyncqueue (thr, true, async);
bool ret = true;
@@ -270,6 +343,12 @@ acc_wait_all_async (int async)
}
gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
if (!ret)
gomp_fatal ("wait all async(%d) failed", async);
}
diff --git a/libgomp/oacc-cuda.c b/libgomp/oacc-cuda.c
index 1a6946c5ddab..07951df5bb0f 100644
--- a/libgomp/oacc-cuda.c
+++ b/libgomp/oacc-cuda.c
@@ -37,10 +37,23 @@ acc_get_current_cuda_device (void)
{
struct goacc_thread *thr = goacc_thread ();
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_device_func)
- return thr->dev->openacc.cuda.get_current_device_func ();
+ {
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
+ ret = thr->dev->openacc.cuda.get_current_device_func ();
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+ }
- return NULL;
+ return ret;
}
void *
@@ -48,10 +61,23 @@ acc_get_current_cuda_context (void)
{
struct goacc_thread *thr = goacc_thread ();
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_context_func)
- return thr->dev->openacc.cuda.get_current_context_func ();
-
- return NULL;
+ {
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
+ ret = thr->dev->openacc.cuda.get_current_context_func ();
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+ }
+
+ return ret;
}
void *
@@ -62,14 +88,32 @@ acc_get_cuda_stream (int async)
if (!async_valid_p (async))
return NULL;
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_stream_func)
{
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
- if (aq)
- return thr->dev->openacc.cuda.get_stream_func (aq);
+ if (!aq)
+ return ret;
+
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
+ ret = thr->dev->openacc.cuda.get_stream_func (aq);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
-
- return NULL;
+
+ return ret;
}
int
@@ -87,6 +131,15 @@ acc_set_cuda_stream (int async, void *stream)
int ret = -1;
if (thr && thr->dev && thr->dev->openacc.cuda.set_stream_func)
{
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq = get_goacc_asyncqueue (async);
/* Due to not using an asyncqueue for "acc_async_sync", this cannot be
used to change the CUDA stream associated with "acc_async_sync". */
@@ -95,11 +148,19 @@ acc_set_cuda_stream (int async, void *stream)
assert (async == acc_async_sync);
gomp_debug (0, "Refusing request to set CUDA stream associated"
" with \"acc_async_sync\"\n");
- return 0;
+ ret = 0;
+ goto out_prof;
}
gomp_mutex_lock (&thr->dev->openacc.async.lock);
ret = thr->dev->openacc.cuda.set_stream_func (aq, stream);
gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+
+ out_prof:
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
return ret;
diff --git a/libgomp/oacc-init.c b/libgomp/oacc-init.c
index 28471e40ba00..e1568c535b32 100644
--- a/libgomp/oacc-init.c
+++ b/libgomp/oacc-init.c
@@ -210,8 +210,67 @@ acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)
held before calling this function. */
static struct gomp_device_descr *
-acc_init_1 (acc_device_t d)
+acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
{
+ bool check_not_nested_p;
+ if (implicit)
+ {
+ /* In the implicit case, there should (TODO: must?) already be something
+ have been set up for an outer construct. */
+ check_not_nested_p = false;
+ }
+ else
+ {
+ check_not_nested_p = true;
+ /* TODO: should we set 'thr->prof_info' etc. in this case ('acc_init')?
+ The problem is, that we don't have 'thr' yet? (So,
+ 'check_not_nested_p = true' also is pointless actually.) */
+ }
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (check_not_nested_p);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_device_init_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = d;
+ prof_info.device_number = goacc_device_num;
+ prof_info.thread_id = -1;
+ prof_info.async = acc_async_sync;
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info device_init_event_info;
+ if (profiling_p)
+ {
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ device_init_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ device_init_event_info.other_event.parent_construct = parent_construct;
+ device_init_event_info.other_event.implicit = implicit;
+ device_init_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info, &api_info);
+
struct gomp_device_descr *base_dev, *acc_dev;
int ndevs;
@@ -234,6 +293,14 @@ acc_init_1 (acc_device_t d)
gomp_init_device (acc_dev);
gomp_mutex_unlock (&acc_dev->lock);
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_device_init_end;
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info,
+ &api_info);
+ }
+
return base_dev;
}
@@ -423,7 +490,11 @@ goacc_attach_host_thread_to_device (int ord)
thr->dev = acc_dev = &base_dev[ord];
thr->saved_bound_dev = NULL;
thr->mapped_data = NULL;
-
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ /* Initially, all callbacks for all events are enabled. */
+ thr->prof_callbacks_enabled = true;
+
thr->target_tls
= acc_dev->openacc.create_thread_data_func (ord);
}
@@ -437,9 +508,7 @@ acc_init (acc_device_t d)
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
-
- cached_base_dev = acc_init_1 (d);
-
+ cached_base_dev = acc_init_1 (d, acc_construct_runtime_api, 0);
gomp_mutex_unlock (&acc_device_lock);
goacc_attach_host_thread_to_device (-1);
@@ -498,6 +567,12 @@ acc_set_device_type (acc_device_t d)
struct gomp_device_descr *base_dev, *acc_dev;
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ prof_info.device_type = d;
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
@@ -522,6 +597,12 @@ acc_set_device_type (acc_device_t d)
}
goacc_attach_host_thread_to_device (-1);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
ialias (acc_set_device_type)
@@ -537,12 +618,22 @@ acc_get_device_type (void)
res = acc_device_type (thr->base_dev->type);
else
{
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (acc_device_default, true);
gomp_mutex_unlock (&acc_device_lock);
res = acc_device_type (dev->type);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
assert (res != acc_device_default
@@ -562,12 +653,24 @@ acc_get_device_num (acc_device_t d)
if (d >= _ACC_device_hwm)
gomp_fatal ("unknown device type %u", (unsigned) d);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ prof_info.device_type = d;
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (d, true);
gomp_mutex_unlock (&acc_device_lock);
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
if (thr && thr->base_dev == dev && thr->dev)
return thr->dev->target_id;
@@ -689,8 +792,13 @@ goacc_lazy_initialize (void)
if (thr && thr->dev)
return;
+ gomp_init_targets_once ();
+
+ gomp_mutex_lock (&acc_device_lock);
if (!cached_base_dev)
- acc_init (acc_device_default);
- else
- goacc_attach_host_thread_to_device (-1);
+ cached_base_dev = acc_init_1 (acc_device_default,
+ acc_construct_parallel, 1);
+ gomp_mutex_unlock (&acc_device_lock);
+
+ goacc_attach_host_thread_to_device (-1);
}
diff --git a/libgomp/oacc-int.h b/libgomp/oacc-int.h
index e4b6ea6b7db4..5ca9944601e2 100644
--- a/libgomp/oacc-int.h
+++ b/libgomp/oacc-int.h
@@ -40,6 +40,7 @@
#include "openacc.h"
#include "config.h"
+#include "acc_prof.h"
#include <stddef.h>
#include <stdbool.h>
#include <stdarg.h>
@@ -68,6 +69,12 @@ struct goacc_thread
strictly push/pop semantics according to lexical scope. */
struct target_mem_desc *mapped_data;
+ /* Data of the OpenACC Profiling Interface. */
+ acc_prof_info *prof_info;
+ acc_api_info *api_info;
+ /* Per-thread toggle of OpenACC Profiling Interface callbacks. */
+ bool prof_callbacks_enabled;
+
/* These structures form a list: this is the next thread in that list. */
struct goacc_thread *next;
@@ -128,6 +135,28 @@ async_synchronous_p (int async)
return async == acc_async_sync;
}
+
+extern bool goacc_prof_enabled;
+/* Tune for the (very common) case that profiling is not enabled. */
+#define GOACC_PROF_ENABLED \
+ (__builtin_expect (__atomic_load_n (&goacc_prof_enabled, \
+ MEMMODEL_ACQUIRE) == true, false))
+
+void goacc_profiling_initialize (void);
+bool _goacc_profiling_dispatch_p (bool);
+/* Tune for the (very common) case that profiling is not enabled. */
+#define GOACC_PROFILING_DISPATCH_P(...) \
+ (GOACC_PROF_ENABLED \
+ && _goacc_profiling_dispatch_p (__VA_ARGS__))
+bool _goacc_profiling_setup_p (struct goacc_thread *,
+ acc_prof_info *, acc_api_info *);
+/* Tune for the (very common) case that profiling is not enabled. */
+#define GOACC_PROFILING_SETUP_P(...) \
+ (GOACC_PROFILING_DISPATCH_P (false) \
+ && _goacc_profiling_setup_p (__VA_ARGS__))
+void goacc_profiling_dispatch (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+
#ifdef HAVE_ATTRIBUTE_VISIBILITY
# pragma GCC visibility pop
#endif
diff --git a/libgomp/oacc-mem.c b/libgomp/oacc-mem.c
index 03df0d4fbf63..0f3832f52b3e 100644
--- a/libgomp/oacc-mem.c
+++ b/libgomp/oacc-mem.c
@@ -108,7 +108,19 @@ acc_malloc (size_t s)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return malloc (s);
- return thr->dev->alloc_func (thr->dev->target_id, s);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
+ void *res = thr->dev->alloc_func (thr->dev->target_id, s);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return res;
}
/* OpenACC 2.0a (3.2.16) doesn't specify what to do in the event
@@ -131,6 +143,10 @@ acc_free (void *d)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return free (d);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
gomp_mutex_lock (&acc_dev->lock);
/* We don't have to call lazy open here, as the ptr value must have
@@ -151,6 +167,12 @@ acc_free (void *d)
if (!acc_dev->free_func (acc_dev->target_id, d))
gomp_fatal ("error in freeing device memory in %s", __FUNCTION__);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
@@ -172,11 +194,26 @@ memcpy_tofrom_device (bool from, void *d, void *h, size_t s, int async,
return;
}
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq = get_goacc_asyncqueue (async);
if (from)
gomp_copy_dev2host (thr->dev, aq, h, d, s);
else
gomp_copy_host2dev (thr->dev, aq, d, h, s, /* TODO: cbuf? */ NULL);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -221,6 +258,9 @@ acc_deviceptr (void *h)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&dev->lock);
n = lookup_host (dev, h, 1);
@@ -258,6 +298,9 @@ acc_hostptr (void *d)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return d;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_dev (acc_dev->openacc.data_environ, d, 1);
@@ -295,6 +338,9 @@ acc_is_present (void *h, size_t s)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h != NULL;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -339,6 +385,10 @@ acc_map_data (void *h, void *d, size_t s)
gomp_fatal ("[%p,+%d]->[%p,+%d] is a bad map",
(void *)h, (int)s, (void *)d, (int)s);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
gomp_mutex_lock (&acc_dev->lock);
if (lookup_host (acc_dev, h, s))
@@ -360,6 +410,12 @@ acc_map_data (void *h, void *d, size_t s)
tgt = gomp_map_vars (acc_dev, mapnum, &hostaddrs, &devaddrs, &sizes,
&kinds, true, GOMP_MAP_VARS_OPENACC);
tgt->list[0].key->refcount = REFCOUNT_INFINITY;
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
gomp_mutex_lock (&acc_dev->lock);
@@ -380,6 +436,10 @@ acc_unmap_data (void *h)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
size_t host_size;
gomp_mutex_lock (&acc_dev->lock);
@@ -433,6 +493,12 @@ acc_unmap_data (void *h)
gomp_mutex_unlock (&acc_dev->lock);
gomp_unmap_vars (t, true);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
#define FLAG_PRESENT (1 << 0)
@@ -456,6 +522,15 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -518,6 +593,12 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
gomp_mutex_unlock (&acc_dev->lock);
}
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return d;
}
@@ -599,6 +680,15 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -672,6 +762,12 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
}
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -737,6 +833,15 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -758,6 +863,12 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
gomp_copy_dev2host (acc_dev, aq, h, d, s);
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
diff --git a/libgomp/oacc-parallel.c b/libgomp/oacc-parallel.c
index fa99a2ad1a90..e56330f6226b 100644
--- a/libgomp/oacc-parallel.c
+++ b/libgomp/oacc-parallel.c
@@ -152,21 +152,75 @@ GOACC_parallel_keyed (int flags_m, void (*fn) (void *),
thr = goacc_thread ();
acc_dev = thr->dev;
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (true);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_compute_construct_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info compute_construct_event_info;
+ if (profiling_p)
+ {
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ compute_construct_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ compute_construct_event_info.other_event.parent_construct
+ = acc_construct_parallel;
+ compute_construct_event_info.other_event.implicit = 0;
+ compute_construct_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds);
/* Host fallback if "if" clause is false or if the current device is set to
the host. */
if (flags & GOACC_FLAG_HOST_FALLBACK)
{
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
goacc_save_and_set_bind (acc_device_host);
fn (hostaddrs);
goacc_restore_bind ();
- return;
+ goto out_prof;
}
else if (acc_device_type (acc_dev->type) == acc_device_host)
{
fn (hostaddrs);
- return;
+ goto out_prof;
}
/* Default: let the runtime choose. */
@@ -200,6 +254,13 @@ GOACC_parallel_keyed (int flags_m, void (*fn) (void *),
if (async == GOMP_LAUNCH_OP_MAX)
async = va_arg (ap, unsigned);
+
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
break;
}
@@ -233,10 +294,34 @@ GOACC_parallel_keyed (int flags_m, void (*fn) (void *),
else
tgt_fn = (void (*)) fn;
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_start;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = compute_construct_event_info.other_event.parent_construct;
+ enter_exit_data_event_info.other_event.implicit = 1;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
+
goacc_aq aq = get_goacc_asyncqueue (async);
tgt = gomp_map_vars_async (acc_dev, aq, mapnum, hostaddrs, NULL, sizes, kinds,
true, GOMP_MAP_VARS_OPENACC);
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
devaddrs = gomp_alloca (sizeof (void *) * mapnum);
for (i = 0; i < mapnum; i++)
@@ -244,17 +329,46 @@ GOACC_parallel_keyed (int flags_m, void (*fn) (void *),
+ tgt->list[i].key->tgt_offset
+ tgt->list[i].offset);
if (aq == NULL)
+ acc_dev->openacc.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs, dims,
+ tgt);
+ else
+ acc_dev->openacc.async.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs,
+ dims, tgt, aq);
+
+ if (profiling_p)
{
- acc_dev->openacc.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs,
- dims, tgt);
- /* If running synchronously, unmap immediately. */
- gomp_unmap_vars (tgt, true);
+ prof_info.event_type = acc_ev_exit_data_start;
+ enter_exit_data_event_info.other_event.event_type = prof_info.event_type;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
}
+
+ /* If running synchronously, unmap immediately. */
+ if (aq == NULL)
+ gomp_unmap_vars (tgt, true);
else
+ gomp_unmap_vars_async (tgt, true, aq);
+
+ if (profiling_p)
{
- acc_dev->openacc.async.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs,
- dims, tgt, aq);
- gomp_unmap_vars_async (tgt, true, aq);
+ prof_info.event_type = acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
+
+ out_prof:
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_compute_construct_end;
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
}
}
@@ -293,16 +407,83 @@ GOACC_data_start (int flags_m, size_t mapnum,
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (true);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_enter_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info enter_data_event_info;
+ if (profiling_p)
+ {
+ enter_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_data_event_info.other_event.parent_construct = acc_construct_data;
+ for (int i = 0; i < mapnum; ++i)
+ if ((kinds[i] & 0xff) == GOMP_MAP_USE_DEVICE_PTR)
+ {
+ /* If there is one such data mapping kind, then this is actually an
+ OpenACC 'host_data' construct. (GCC maps the OpenACC
+ 'host_data' construct to the OpenACC 'data' construct.) Apart
+ from artificial test cases (such as an OpenACC 'host_data'
+ construct's (implicit) device initialization when there hasn't
+ been any device data be set up before...), there can't really
+ any meaningful events be generated from OpenACC 'host_data'
+ constructs, though. */
+ enter_data_event_info.other_event.parent_construct
+ = acc_construct_host_data;
+ break;
+ }
+ enter_data_event_info.other_event.implicit = 0;
+ enter_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
/* Host fallback or 'do nothing'. */
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| (flags & GOACC_FLAG_HOST_FALLBACK))
{
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
tgt = gomp_map_vars (NULL, 0, NULL, NULL, NULL, NULL, true,
GOMP_MAP_VARS_OPENACC);
tgt->prev = thr->mapped_data;
thr->mapped_data = tgt;
- return;
+ goto out_prof;
}
gomp_debug (0, " %s: prepare mappings\n", __FUNCTION__);
@@ -311,18 +492,90 @@ GOACC_data_start (int flags_m, size_t mapnum,
gomp_debug (0, " %s: mappings prepared\n", __FUNCTION__);
tgt->prev = thr->mapped_data;
thr->mapped_data = tgt;
+
+ out_prof:
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_data_end (void)
{
struct goacc_thread *thr = goacc_thread ();
+ struct gomp_device_descr *acc_dev = thr->dev;
struct target_mem_desc *tgt = thr->mapped_data;
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (true);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info exit_data_event_info;
+ if (profiling_p)
+ {
+ exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ exit_data_event_info.other_event.parent_construct = acc_construct_data;
+ exit_data_event_info.other_event.implicit = 0;
+ exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
gomp_debug (0, " %s: restore mappings\n", __FUNCTION__);
thr->mapped_data = tgt->prev;
gomp_unmap_vars (tgt, true);
gomp_debug (0, " %s: mappings restored\n", __FUNCTION__);
+
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_end;
+ exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -342,19 +595,6 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
thr = goacc_thread ();
acc_dev = thr->dev;
- if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- || (flags & GOACC_FLAG_HOST_FALLBACK))
- return;
-
- if (num_waits)
- {
- va_list ap;
-
- va_start (ap, num_waits);
- goacc_wait (async, num_waits, &ap);
- va_end (ap);
- }
-
/* Determine whether "finalize" semantics apply to all mappings of this
OpenACC directive. */
bool finalize = false;
@@ -394,6 +634,77 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
kind);
}
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (true);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type
+ = data_enter ? acc_ev_enter_data_start : acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_p)
+ {
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = data_enter ? acc_construct_enter_data : acc_construct_exit_data;
+ enter_exit_data_event_info.other_event.implicit = 0;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
+ || (flags & GOACC_FLAG_HOST_FALLBACK))
+ {
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+
+ goto out_prof;
+ }
+
+ if (num_waits)
+ {
+ va_list ap;
+
+ va_start (ap, num_waits);
+ goacc_wait (async, num_waits, &ap);
+ va_end (ap);
+ }
+
/* In c, non-pointers and arrays are represented by a single data clause.
Dynamically allocated arrays and subarrays are represented by a data
clause followed by an internal GOMP_MAP_POINTER.
@@ -486,6 +797,19 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
i += pointer - 1;
}
}
+
+ out_prof:
+ if (profiling_p)
+ {
+ prof_info.event_type
+ = data_enter ? acc_ev_enter_data_end : acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
@@ -534,9 +858,64 @@ GOACC_update (int flags_m, size_t mapnum,
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (true);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_update_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info update_event_info;
+ if (profiling_p)
+ {
+ update_event_info.other_event.event_type
+ = prof_info.event_type;
+ update_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ update_event_info.other_event.parent_construct = acc_construct_update;
+ update_event_info.other_event.implicit = 0;
+ update_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| (flags & GOACC_FLAG_HOST_FALLBACK))
- return;
+ {
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+
+ goto out_prof;
+ }
if (num_waits)
{
@@ -608,11 +987,38 @@ GOACC_update (int flags_m, size_t mapnum,
break;
}
}
+
+ out_prof:
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_update_end;
+ update_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_wait (int async, int num_waits, ...)
{
+ goacc_lazy_initialize ();
+
+ struct goacc_thread *thr = goacc_thread ();
+
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
if (num_waits)
{
va_list ap;
@@ -625,6 +1031,12 @@ GOACC_wait (int async, int num_waits, ...)
acc_wait_all ();
else
acc_wait_all_async (async);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
/* Legacy entry point (GCC 5). */
diff --git a/libgomp/oacc-plugin.c b/libgomp/oacc-plugin.c
index 5480c1db56ee..b4f71a11c18b 100644
--- a/libgomp/oacc-plugin.c
+++ b/libgomp/oacc-plugin.c
@@ -29,6 +29,7 @@
#include "libgomp.h"
#include "oacc-plugin.h"
#include "oacc-int.h"
+#include "acc_prof.h"
/* This plugin function is now obsolete. */
void
@@ -38,6 +39,14 @@ GOMP_PLUGIN_async_unmap_vars (void *ptr __attribute__((unused)),
gomp_fatal ("invalid plugin function");
}
+/* Return the TLS data for the current thread. */
+
+struct goacc_thread *
+GOMP_PLUGIN_goacc_thread (void)
+{
+ return goacc_thread ();
+}
+
/* Return the target-specific part of the TLS data for the current thread. */
void *
@@ -57,3 +66,11 @@ GOMP_PLUGIN_acc_default_dim (unsigned int i)
}
return goacc_default_dims[i];
}
+
+void
+GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *prof_info,
+ acc_event_info *event_info,
+ acc_api_info *api_info)
+{
+ goacc_profiling_dispatch (prof_info, event_info, api_info);
+}
diff --git a/libgomp/oacc-plugin.h b/libgomp/oacc-plugin.h
index 112d4a593f97..887c6f601253 100644
--- a/libgomp/oacc-plugin.h
+++ b/libgomp/oacc-plugin.h
@@ -27,8 +27,15 @@
#ifndef OACC_PLUGIN_H
#define OACC_PLUGIN_H 1
+#include "oacc-int.h"
+#include "acc_prof.h"
+
extern void GOMP_PLUGIN_async_unmap_vars (void *, int);
+extern struct goacc_thread *GOMP_PLUGIN_goacc_thread (void);
extern void *GOMP_PLUGIN_acc_thread (void);
extern int GOMP_PLUGIN_acc_default_dim (unsigned int);
+extern void GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *,
+ acc_event_info *,
+ acc_api_info *);
#endif
diff --git a/libgomp/oacc-profiling.c b/libgomp/oacc-profiling.c
new file mode 100644
index 000000000000..eff288650895
--- /dev/null
+++ b/libgomp/oacc-profiling.c
@@ -0,0 +1,662 @@
+/* OpenACC Profiling Interface
+
+ Copyright (C) 2019 Free Software Foundation, Inc.
+
+ Contributed by Mentor, a Siemens Business.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+#define _GNU_SOURCE
+#include "libgomp.h"
+#include "oacc-int.h"
+#include "secure_getenv.h"
+#include "acc_prof.h"
+#include <assert.h>
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+#ifdef PLUGIN_SUPPORT
+# include <dlfcn.h>
+#endif
+
+#define STATIC_ASSERT(expr) _Static_assert (expr, "!(" #expr ")")
+
+/* Statically assert that the layout of the common fields in the
+ 'acc_event_info' variants matches. */
+/* 'event_type' */
+STATIC_ASSERT (offsetof (acc_event_info, event_type)
+ == offsetof (acc_event_info, data_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, launch_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, other_event.event_type));
+/* 'valid_bytes' */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, launch_event.valid_bytes));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, other_event.valid_bytes));
+/* 'parent_construct' */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, launch_event.parent_construct));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, other_event.parent_construct));
+/* 'implicit' */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, launch_event.implicit));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, other_event.implicit));
+/* 'tool_info' */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, launch_event.tool_info));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, other_event.tool_info));
+
+struct goacc_prof_callback_entry
+{
+ acc_prof_callback cb;
+ int ref;
+ bool enabled;
+ struct goacc_prof_callback_entry *next;
+};
+
+/* Use a separate flag to minimize run-time performance impact for the (very
+ common) case that profiling is not enabled.
+
+ Once enabled, we're not going to disable this anymore, anywhere. We
+ probably could, by adding appropriate logic to 'acc_prof_register',
+ 'acc_prof_unregister'. */
+bool goacc_prof_enabled = false;
+
+/* Global state for registered callbacks.
+ 'goacc_prof_callbacks_enabled[acc_ev_none]' acts as a global toggle. */
+static bool goacc_prof_callbacks_enabled[acc_ev_last];
+static struct goacc_prof_callback_entry *goacc_prof_callback_entries[acc_ev_last];
+/* Lock used to protect access to 'goacc_prof_callbacks_enabled', and
+ 'goacc_prof_callback_entries'. */
+static gomp_mutex_t goacc_prof_lock;
+
+void
+goacc_profiling_initialize (void)
+{
+ gomp_mutex_init (&goacc_prof_lock);
+
+ /* Initially, all callbacks for all events are enabled. */
+ for (int i = 0; i < acc_ev_last; ++i)
+ goacc_prof_callbacks_enabled[i] = true;
+
+
+#ifdef PLUGIN_SUPPORT
+ char *acc_proflibs = secure_getenv ("ACC_PROFLIB");
+ while (acc_proflibs != NULL && acc_proflibs[0] != '\0')
+ {
+ char *acc_proflibs_sep = strchr (acc_proflibs, ';');
+ char *acc_proflib;
+ if (acc_proflibs_sep == acc_proflibs)
+ {
+ /* Stray ';' separator: make sure we don't 'dlopen' the main
+ program. */
+ acc_proflib = NULL;
+ }
+ else
+ {
+ if (acc_proflibs_sep != NULL)
+ {
+ /* Single out the first library. */
+ acc_proflib = gomp_malloc (acc_proflibs_sep - acc_proflibs + 1);
+ memcpy (acc_proflib, acc_proflibs,
+ acc_proflibs_sep - acc_proflibs);
+ acc_proflib[acc_proflibs_sep - acc_proflibs] = '\0';
+ }
+ else
+ {
+ /* No ';' separator, so only one library. */
+ acc_proflib = acc_proflibs;
+ }
+
+ gomp_debug (0, "%s: dlopen (\"%s\")\n", __FUNCTION__, acc_proflib);
+ void *dl_handle = dlopen (acc_proflib, RTLD_LAZY);
+ if (dl_handle != NULL)
+ {
+ typeof (&acc_register_library) a_r_l
+ = dlsym (dl_handle, "acc_register_library");
+ if (a_r_l == NULL)
+ goto dl_fail;
+ gomp_debug (0, " %s: calling %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ a_r_l (acc_prof_register, acc_prof_unregister,
+ acc_prof_lookup);
+ }
+ else
+ {
+ dl_fail:
+ gomp_error ("while loading ACC_PROFLIB \"%s\": %s",
+ acc_proflib, dlerror ());
+ if (dl_handle != NULL)
+ {
+ int err = dlclose (dl_handle);
+ dl_handle = NULL;
+ if (err != 0)
+ goto dl_fail;
+ }
+ }
+ }
+
+ if (acc_proflib != acc_proflibs)
+ {
+ free (acc_proflib);
+
+ acc_proflibs = acc_proflibs_sep + 1;
+ }
+ else
+ acc_proflibs = NULL;
+ }
+#endif /* PLUGIN_SUPPORT */
+}
+
+void
+acc_prof_register (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+
+ /* For any events to be dispatched, the user first has to register a
+ callback, which makes this here a good place for enabling the whole
+ machinery. */
+ if (!GOACC_PROF_ENABLED)
+ __atomic_store_n (&goacc_prof_enabled, true, MEMMODEL_RELEASE);
+
+
+ enum
+ {
+ EVENT_KIND_BOGUS,
+ EVENT_KIND_NORMAL,
+ /* As end events invoke callbacks in the reverse order, we register these
+ in the reverse order here. */
+ EVENT_KIND_END,
+ } event_kind = EVENT_KIND_BOGUS;
+ switch (ev)
+ {
+ case acc_ev_none:
+ case acc_ev_device_init_start:
+ case acc_ev_device_shutdown_start:
+ case acc_ev_runtime_shutdown:
+ case acc_ev_create:
+ case acc_ev_delete:
+ case acc_ev_alloc:
+ case acc_ev_free:
+ case acc_ev_enter_data_start:
+ case acc_ev_exit_data_start:
+ case acc_ev_update_start:
+ case acc_ev_compute_construct_start:
+ case acc_ev_enqueue_launch_start:
+ case acc_ev_enqueue_upload_start:
+ case acc_ev_enqueue_download_start:
+ case acc_ev_wait_start:
+ event_kind = EVENT_KIND_NORMAL;
+ break;
+ case acc_ev_device_init_end:
+ case acc_ev_device_shutdown_end:
+ case acc_ev_enter_data_end:
+ case acc_ev_exit_data_end:
+ case acc_ev_update_end:
+ case acc_ev_compute_construct_end:
+ case acc_ev_enqueue_launch_end:
+ case acc_ev_enqueue_upload_end:
+ case acc_ev_enqueue_download_end:
+ case acc_ev_wait_end:
+ event_kind = EVENT_KIND_END;
+ break;
+ case acc_ev_last:
+ break;
+ }
+ if (event_kind == EVENT_KIND_BOGUS)
+ {
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring request for bogus 'acc_event_t'\n");
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring request with bogus 'acc_register_t'\n");
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally enabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* For 'acc_ev_none', this acts as a global toggle. */
+ goacc_prof_callbacks_enabled[ev] = true;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: enabling callbacks\n");
+ goacc_lazy_initialize ();
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = true;
+ return;
+ }
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring bogus request\n");
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ /* If we already have this callback registered, just increment its
+ reference count. */
+ if (it != NULL)
+ {
+ it->ref++;
+ gomp_debug (0, " already registered;"
+ " incrementing reference count to: %d\n", it->ref);
+ }
+ else
+ {
+ struct goacc_prof_callback_entry *e
+ = gomp_malloc (sizeof (struct goacc_prof_callback_entry));
+ e->cb = cb;
+ e->ref = 1;
+ e->enabled = true;
+ bool prepend = (event_kind == EVENT_KIND_END);
+ /* If we don't have any callback registered yet, also use the
+ 'prepend' code path. */
+ if (it_p == NULL)
+ prepend = true;
+ if (prepend)
+ {
+ gomp_debug (0, " prepending\n");
+ e->next = goacc_prof_callback_entries[ev];
+ goacc_prof_callback_entries[ev] = e;
+ }
+ else
+ {
+ gomp_debug (0, " appending\n");
+ e->next = NULL;
+ it_p->next = e;
+ }
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ gomp_debug (0, " ignoring request: is not registered\n");
+ break;
+ }
+ else
+ {
+ gomp_debug (0, " enabling\n");
+ it->enabled = true;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+void
+acc_prof_unregister (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+ /* If profiling is not enabled, there cannot be anything to unregister. */
+ if (!GOACC_PROF_ENABLED)
+ return;
+
+ if (ev < acc_ev_none
+ || ev >= acc_ev_last)
+ {
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring request for bogus 'acc_event_t'\n");
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring request with bogus 'acc_register_t'\n");
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally disabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* For 'acc_ev_none', this acts as a global toggle. */
+ goacc_prof_callbacks_enabled[ev] = false;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: disabling callbacks\n");
+ goacc_lazy_initialize ();
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = false;
+ return;
+ }
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring bogus request\n");
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ if (it == NULL)
+ {
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring bogus request: is not registered\n");
+ break;
+ }
+ it->ref--;
+ gomp_debug (0, " decrementing reference count to: %d\n", it->ref);
+ if (it->ref == 0)
+ {
+ if (it_p == NULL)
+ goacc_prof_callback_entries[ev] = it->next;
+ else
+ it_p->next = it->next;
+ free (it);
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ gomp_debug (0, " ignoring request: is not registered\n");
+ break;
+ }
+ else
+ {
+ gomp_debug (0, " disabling\n");
+ it->enabled = false;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+acc_query_fn
+acc_prof_lookup (const char *name)
+{
+ gomp_debug (0, "%s (%s)\n",
+ __FUNCTION__, name ?: "NULL");
+
+ return NULL;
+}
+
+void
+acc_register_library (acc_prof_reg reg, acc_prof_reg unreg,
+ acc_prof_lookup_func lookup)
+{
+ gomp_fatal ("TODO");
+}
+
+/* Prepare to dispatch events? */
+
+bool
+_goacc_profiling_dispatch_p (bool check_not_nested_p)
+{
+ gomp_debug (0, "%s\n", __FUNCTION__);
+
+ bool ret;
+
+ struct goacc_thread *thr = goacc_thread ();
+ if (__builtin_expect (thr == NULL, false))
+ {
+ /* If we don't have any per-thread state yet, that means that per-thread
+ callback dispatch has not been explicitly disabled (which only a call
+ to 'acc_prof_unregister' with 'acc_toggle_per_thread' would do, and
+ that would have allocated per-thread state via
+ 'goacc_lazy_initialize'); initially, all callbacks for all events are
+ enabled. */
+ gomp_debug (0, " %s: don't have any per-thread state yet\n", __FUNCTION__);
+ }
+ else
+ {
+ if (check_not_nested_p)
+ {
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ }
+
+ if (__builtin_expect (!thr->prof_callbacks_enabled, true))
+ {
+ gomp_debug (0, " %s: disabled for this thread\n", __FUNCTION__);
+ ret = false;
+ goto out;
+ }
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ /* 'goacc_prof_callbacks_enabled[acc_ev_none]' acts as a global toggle. */
+ if (__builtin_expect (!goacc_prof_callbacks_enabled[acc_ev_none], true))
+ {
+ gomp_debug (0, " %s: disabled globally\n", __FUNCTION__);
+ ret = false;
+ goto out_unlock;
+ }
+ else
+ ret = true;
+
+ out_unlock:
+ gomp_mutex_unlock (&goacc_prof_lock);
+
+ out:
+ return ret;
+}
+
+/* Set up to dispatch events? */
+
+bool
+_goacc_profiling_setup_p (struct goacc_thread *thr,
+ acc_prof_info *prof_info, acc_api_info *api_info)
+{
+ gomp_debug (0, "%s (%p)\n", __FUNCTION__, thr);
+
+ /* If we don't have any per-thread state yet, we can't register 'prof_info'
+ and 'api_info'. */
+ if (__builtin_expect (thr == NULL, false))
+ {
+ gomp_debug (0, "Can't dispatch OpenACC Profiling Interface events for"
+ " the current call, construct, or directive\n");
+ return false;
+ }
+
+ if (thr->prof_info != NULL)
+ {
+ /* Profiling has already been set up for an outer construct. In this
+ case, we continue to use the existing information, and thus return
+ 'false' here.
+
+ This can happen, for example, for an 'enter data' directive, which
+ sets up profiling, then calls into 'acc_copyin', which should not
+ again set up profiling, should not overwrite the existing
+ information. */
+ return false;
+ }
+
+ thr->prof_info = prof_info;
+ thr->api_info = api_info;
+
+ /* Fill in some defaults. */
+
+ prof_info->event_type = -1; /* Must be set later. */
+ prof_info->valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info->version = _ACC_PROF_INFO_VERSION;
+ if (thr->dev)
+ {
+ prof_info->device_type = acc_device_type (thr->dev->type);
+ prof_info->device_number = thr->dev->target_id;
+ }
+ else
+ {
+ prof_info->device_type = -1;
+ prof_info->device_number = -1;
+ }
+ prof_info->thread_id = -1;
+ prof_info->async = acc_async_sync;
+ prof_info->async_queue = prof_info->async;
+ prof_info->src_file = NULL;
+ prof_info->func_name = NULL;
+ prof_info->line_no = -1;
+ prof_info->end_line_no = -1;
+ prof_info->func_line_no = -1;
+ prof_info->func_end_line_no = -1;
+
+ api_info->device_api = acc_device_api_none;
+ api_info->valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info->device_type = prof_info->device_type;
+ api_info->vendor = -1;
+ api_info->device_handle = NULL;
+ api_info->context_handle = NULL;
+ api_info->async_handle = NULL;
+
+ return true;
+}
+
+/* Dispatch events.
+
+ This must only be called if 'GOACC_PROFILING_DISPATCH_P' or
+ 'GOACC_PROFILING_SETUP_P' returned a true result. */
+
+void
+goacc_profiling_dispatch (acc_prof_info *prof_info, acc_event_info *event_info,
+ acc_api_info *apt_info)
+{
+ acc_event_t event_type = event_info->event_type;
+ gomp_debug (0, "%s: event_type=%d\n", __FUNCTION__, (int) event_type);
+ assert (event_type > acc_ev_none
+ && event_type < acc_ev_last);
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ if (!goacc_prof_callbacks_enabled[event_type])
+ {
+ gomp_debug (0, " disabled for this event type\n");
+
+ goto out_unlock;
+ }
+
+ for (struct goacc_prof_callback_entry *e
+ = goacc_prof_callback_entries[event_type];
+ e != NULL;
+ e = e->next)
+ {
+ if (!e->enabled)
+ {
+ gomp_debug (0, " disabled for callback %p\n", e->cb);
+ continue;
+ }
+
+ gomp_debug (0, " calling callback %p\n", e->cb);
+ e->cb (prof_info, event_info, apt_info);
+ }
+
+ out_unlock:
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
diff --git a/libgomp/plugin/plugin-nvptx.c b/libgomp/plugin/plugin-nvptx.c
index 8f71e69acb60..3469116cf610 100644
--- a/libgomp/plugin/plugin-nvptx.c
+++ b/libgomp/plugin/plugin-nvptx.c
@@ -37,6 +37,7 @@
#include "libgomp-plugin.h"
#include "oacc-plugin.h"
#include "gomp-constants.h"
+#include "oacc-int.h"
#include <pthread.h>
#include <cuda.h>
@@ -904,27 +905,122 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
// num_gangs nctaid.x
// num_workers ntid.y
// vector length ntid.x
+
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info enqueue_launch_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_start;
+
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ enqueue_launch_event_info.launch_event.valid_bytes
+ = _ACC_LAUNCH_EVENT_INFO_VALID_BYTES;
+ enqueue_launch_event_info.launch_event.parent_construct
+ = acc_construct_parallel;
+ enqueue_launch_event_info.launch_event.implicit = 1;
+ enqueue_launch_event_info.launch_event.tool_info = NULL;
+ enqueue_launch_event_info.launch_event.kernel_name = targ_fn->launch->fn;
+ enqueue_launch_event_info.launch_event.num_gangs
+ = dims[GOMP_DIM_GANG];
+ enqueue_launch_event_info.launch_event.num_workers
+ = dims[GOMP_DIM_WORKER];
+ enqueue_launch_event_info.launch_event.vector_length
+ = dims[GOMP_DIM_VECTOR];
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
+
kargs[0] = &dp;
CUDA_CALL_ASSERT (cuLaunchKernel, function,
dims[GOMP_DIM_GANG], 1, 1,
dims[GOMP_DIM_VECTOR], dims[GOMP_DIM_WORKER], 1,
0, stream, kargs, 0);
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_end;
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
+
GOMP_PLUGIN_debug (0, " %s: kernel %s: finished\n", __FUNCTION__,
targ_fn->launch->fn);
}
void * openacc_get_current_cuda_context (void);
+static void
+goacc_profiling_acc_ev_alloc (struct goacc_thread *thr, void *dp, size_t s)
+{
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_alloc;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct = acc_construct_parallel;
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL;
+ data_event_info.data_event.bytes = s;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info, api_info);
+}
+
static void *
nvptx_alloc (size_t s)
{
CUdeviceptr d;
CUDA_CALL_ERET (NULL, cuMemAlloc, &d, s);
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ bool profiling_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ if (profiling_p)
+ goacc_profiling_acc_ev_alloc (thr, (void *) d, s);
+
return (void *) d;
}
+static void
+goacc_profiling_acc_ev_free (struct goacc_thread *thr, void *p)
+{
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_free;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct = acc_construct_parallel;
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL;
+ data_event_info.data_event.bytes = -1;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = p;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info, api_info);
+}
+
static bool
nvptx_free (void *p, struct ptx_device *ptx_dev)
{
@@ -952,6 +1048,12 @@ nvptx_free (void *p, struct ptx_device *ptx_dev)
}
CUDA_CALL (cuMemFree, (CUdeviceptr) p);
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ bool profiling_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ if (profiling_p)
+ goacc_profiling_acc_ev_free (thr, p);
+
return true;
}
@@ -1250,22 +1352,61 @@ GOMP_OFFLOAD_openacc_exec (void (*fn) (void *), size_t mapnum,
{
GOMP_PLUGIN_debug (0, " %s: prepare mappings\n", __FUNCTION__);
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_p = __builtin_expect (prof_info != NULL, false);
+
void **hp = NULL;
CUdeviceptr dp = 0;
if (mapnum > 0)
{
- hp = alloca (mapnum * sizeof (void *));
+ size_t s = mapnum * sizeof (void *);
+ hp = alloca (s);
for (int i = 0; i < mapnum; i++)
hp[i] = (devaddrs[i] ? devaddrs[i] : hostaddrs[i]);
- CUDA_CALL_ASSERT (cuMemAlloc, &dp, mapnum * sizeof (void *));
+ CUDA_CALL_ASSERT (cuMemAlloc, &dp, s);
+ if (profiling_p)
+ goacc_profiling_acc_ev_alloc (thr, (void *) dp, s);
}
/* Copy the (device) pointers to arguments to the device (dp and hp might in
fact have the same value on a unified-memory system). */
if (mapnum > 0)
- CUDA_CALL_ASSERT (cuMemcpyHtoD, dp, (void *) hp,
- mapnum * sizeof (void *));
+ {
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel;
+ data_event_info.data_event.implicit = 1; /* Always implicit. */
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL;
+ data_event_info.data_event.bytes = mapnum * sizeof (void *);
+ data_event_info.data_event.host_ptr = hp;
+ data_event_info.data_event.device_ptr = (const void *) dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+ CUDA_CALL_ASSERT (cuMemcpyHtoD, dp, (void *) hp,
+ mapnum * sizeof (void *));
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+ }
nvptx_exec (fn, mapnum, hostaddrs, devaddrs, dims, targ_mem_desc,
dp, NULL);
@@ -1277,7 +1418,10 @@ GOMP_OFFLOAD_openacc_exec (void (*fn) (void *), size_t mapnum,
maybe_abort_msg);
else if (r != CUDA_SUCCESS)
GOMP_PLUGIN_fatal ("cuStreamSynchronize error: %s", cuda_error (r));
+
CUDA_CALL_ASSERT (cuMemFree, dp);
+ if (profiling_p)
+ goacc_profiling_acc_ev_free (thr, (void *) dp);
}
static void
@@ -1296,23 +1440,54 @@ GOMP_OFFLOAD_openacc_async_exec (void (*fn) (void *), size_t mapnum,
{
GOMP_PLUGIN_debug (0, " %s: prepare mappings\n", __FUNCTION__);
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_p = __builtin_expect (prof_info != NULL, false);
+
void **hp = NULL;
CUdeviceptr dp = 0;
void **block = NULL;
if (mapnum > 0)
{
- block = (void **) GOMP_PLUGIN_malloc ((mapnum + 2) * sizeof (void *));
+ size_t s = mapnum * sizeof (void *);
+ block = (void **) GOMP_PLUGIN_malloc (2 * sizeof (void *) + s);
hp = block + 2;
for (int i = 0; i < mapnum; i++)
hp[i] = (devaddrs[i] ? devaddrs[i] : hostaddrs[i]);
- CUDA_CALL_ASSERT (cuMemAlloc, &dp, mapnum * sizeof (void *));
+ CUDA_CALL_ASSERT (cuMemAlloc, &dp, s);
+ if (profiling_p)
+ goacc_profiling_acc_ev_alloc (thr, (void *) dp, s);
}
/* Copy the (device) pointers to arguments to the device (dp and hp might in
fact have the same value on a unified-memory system). */
if (mapnum > 0)
{
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel;
+ data_event_info.data_event.implicit = 1; /* Always implicit. */
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL;
+ data_event_info.data_event.bytes = mapnum * sizeof (void *);
+ data_event_info.data_event.host_ptr = hp;
+ data_event_info.data_event.device_ptr = (const void *) dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
CUDA_CALL_ASSERT (cuMemcpyHtoDAsync, dp, (void *) hp,
mapnum * sizeof (void *), aq->cuda_stream);
block[0] = (void *) dp;
@@ -1320,7 +1495,16 @@ GOMP_OFFLOAD_openacc_async_exec (void (*fn) (void *), size_t mapnum,
struct nvptx_thread *nvthd =
(struct nvptx_thread *) GOMP_PLUGIN_acc_thread ();
block[1] = (void *) nvthd->ptx_dev;
+
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
}
+
nvptx_exec (fn, mapnum, hostaddrs, devaddrs, dims, targ_mem_desc,
dp, aq->cuda_stream);
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
new file mode 100644
index 000000000000..d929bfd80a4f
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
@@ -0,0 +1,353 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit 'copyin' clauses, to work around "'firstprivate'
+ optimizations", which will cause the value at the point of call to be used
+ (*before* any potential modifications done in callbacks), as opposed to its
+ address being taken, which then later gets dereferenced (*after* any
+ modifications done in callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int state = -1;
+
+#define STATE_OP(state, op) \
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+static void cb_compute_construct_start_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 10
+ || state == 30
+ || state == 41
+ || state == 51
+ || state == 91
+ || state == 101
+ || state == 151);
+ STATE_OP (state, ++);
+}
+
+static void cb_compute_construct_start_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 11
+ || state == 40
+ || state == 50
+ || state == 90
+ || state == 100
+ || state == 150);
+ STATE_OP (state, ++);
+}
+
+static void cb_compute_construct_end_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 14
+ || state == 21
+ || state == 32
+ || state == 42
+ || state == 80
+ || state == 103
+ || state == 152);
+ STATE_OP (state, ++);
+}
+
+static void cb_compute_construct_end_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 13
+ || state == 43
+ || state == 102
+ || state == 154);
+ STATE_OP (state, ++);
+}
+
+static void cb_compute_construct_end_3 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 12
+ || state == 20
+ || state == 31
+ || state == 44
+ || state == 81
+ || state == 104
+ || state == 153);
+ STATE_OP (state, ++);
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ STATE_OP (state, = 0);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 2);
+ }
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 12);
+ }
+ assert (state == 15);
+
+ STATE_OP (state, = 20);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 20);
+ }
+ assert (state == 20);
+
+ STATE_OP (state, = 30);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 31);
+ }
+ assert (state == 33);
+
+ STATE_OP (state, = 40);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 42);
+ }
+ assert (state == 45);
+
+ STATE_OP (state, = 50);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 52);
+ }
+ assert (state == 52);
+
+ STATE_OP (state, = 60);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 60);
+ }
+ assert (state == 60);
+
+ STATE_OP (state, = 70);
+ unreg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 70);
+ }
+ assert (state == 70);
+
+ STATE_OP (state, = 80);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 80);
+ }
+ assert (state == 82);
+
+ STATE_OP (state, = 90);
+ reg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 92);
+ }
+ assert (state == 92);
+
+ STATE_OP (state, = 100);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 102);
+ }
+ assert (state == 105);
+
+ STATE_OP (state, = 110);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 110);
+ }
+ assert (state == 110);
+
+ STATE_OP (state, = 120);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 120);
+ }
+ assert (state == 120);
+
+ STATE_OP (state, = 130);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 130);
+ }
+ assert (state == 130);
+
+ STATE_OP (state, = 140);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 140);
+ }
+ assert (state == 140);
+
+ STATE_OP (state, = 150);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 152);
+ }
+ assert (state == 155);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
new file mode 100644
index 000000000000..b356feb8108c
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
@@ -0,0 +1,316 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit 'copyin' clauses, to work around "'firstprivate'
+ optimizations", which will cause the value at the point of call to be used
+ (*before* any potential modifications done in callbacks), as opposed to its
+ address being taken, which then later gets dereferenced (*after* any
+ modifications done in callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int state = -1;
+
+#define STATE_OP(state, op) \
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+static void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 1)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+static void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 2)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+static void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 10
+ || state == 110);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+static void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 11
+ || state == 111);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ assert (state == 0);
+
+ acc_init (acc_device_host);
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = 12;
+
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 11);
+ }
+ assert (state == 12);
+
+ STATE_OP (state, = 90);
+ acc_shutdown (acc_device_host);
+ assert (state == 90);
+
+
+ STATE_OP (state, = 100);
+ acc_init (acc_device_default);
+ assert (state == 102);
+
+ STATE_OP (state, = 110);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = 12;
+
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 111);
+ }
+ assert (state == 112);
+
+ STATE_OP (state, = 190);
+ acc_shutdown (acc_device_default);
+ assert (state == 190);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
new file mode 100644
index 000000000000..7cfc364e4113
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
@@ -0,0 +1,229 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit 'copyin' clauses, to work around "'firstprivate'
+ optimizations", which will cause the value at the point of call to be used
+ (*before* any potential modifications done in callbacks), as opposed to its
+ address being taken, which then later gets dereferenced (*after* any
+ modifications done in callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+/* See the 'DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT' reference in
+ 'libgomp.texi'. */
+#define DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT 0
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+volatile // TODO PR90488
+static int state = -1;
+
+#define STATE_OP(state, op) \
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int num_gangs, num_workers, vector_length;
+
+
+static void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 0);
+ STATE_OP (state, = 1);
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == NULL);
+ assert (event_info->launch_event.kernel_name != NULL);
+ {
+ const char *s = strstr (event_info->launch_event.kernel_name, "main");
+ assert (s != NULL);
+ s = strstr (s, "omp_fn");
+ assert (s != NULL);
+ }
+ if (num_gangs < 1)
+ assert (event_info->launch_event.num_gangs >= 1);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.num_gangs == num_gangs);
+#else
+ /* No parallelized OpenACC 'kernels' constructs. Unparallelized OpenACC
+ 'kernels' constructs must get launched as 1 x 1 x 1 GPU kernels. */
+ assert (event_info->launch_event.num_gangs == 1);
+#endif
+ }
+ if (num_workers < 1)
+ assert (event_info->launch_event.num_workers >= 1);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.num_workers == num_workers);
+#else
+ /* See 'num_gangs' above. */
+ assert (event_info->launch_event.num_workers == 1);
+#endif
+ }
+ if (vector_length < 1)
+ assert (event_info->launch_event.vector_length >= 1);
+ else if (acc_device_type == acc_device_nvidia) /* ... is special. */
+ assert (event_info->launch_event.vector_length == 32);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.vector_length == vector_length);
+#else
+ /* See 'num_gangs' above. */
+ assert (event_info->launch_event.vector_length == 1);
+#endif
+ }
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ STATE_OP (state, = 0);
+ reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
+ assert (state == 0);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ assert (state == 0);
+
+ /* Parallelism dimensions: compiler/runtime decides. */
+ STATE_OP (state, = 0);
+ num_gangs = num_workers = vector_length = 0;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No 'acc_ev_enqueue_launch_start'. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ /* Parallelism dimensions: literal. */
+ STATE_OP (state, = 0);
+ num_gangs = 30;
+ num_workers = 3;
+ vector_length = 5;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels \
+ num_gangs (30) num_workers (3) vector_length (5)
+ /* { dg-prune-output "using vector_length \\(32\\), ignoring 5" } */
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No 'acc_ev_enqueue_launch_start'. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ /* Parallelism dimensions: variable. */
+ STATE_OP (state, = 0);
+ num_gangs = 22;
+ num_workers = 5;
+ vector_length = 7;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels \
+ num_gangs (num_gangs) num_workers (num_workers) vector_length (vector_length)
+ /* { dg-prune-output "using vector_length \\(32\\), ignoring runtime setting" } */
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No 'acc_ev_enqueue_launch_start'. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
new file mode 100644
index 000000000000..ac6eb48cbbef
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
@@ -0,0 +1,719 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit 'copyin' clauses, to work around "'firstprivate'
+ optimizations", which will cause the value at the point of call to be used
+ (*before* any potential modifications done in callbacks), as opposed to its
+ address being taken, which then later gets dereferenced (*after* any
+ modifications done in callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+/* See the 'DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT' reference in
+ libgomp.texi. */
+#define DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT 0
+
+
+/* Do we expect to see 'acc_ev_exit_data_start' and 'acc_ev_exit_data_end'
+ after a compute construct with an 'async' clause? */
+#define ASYNC_EXIT_DATA 1
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int state = -1;
+
+#define STATE_OP(state, op) \
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+static void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+#else
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+#else
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+#endif
+}
+
+static void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 2
+ || state == 102);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_device_init_start);
+#else
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (event_info->other_event.tool_info == tool_info->nested);
+#else
+ assert (event_info->other_event.tool_info == tool_info);
+#endif
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+#else
+ free (tool_info);
+ tool_info = NULL;
+#endif
+}
+
+static void cb_enter_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 3
+ || state == 103);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enter_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+static void cb_enter_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 4
+ || state == 104);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_enter_data_start);
+
+ assert (prof_info->event_type == acc_ev_enter_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+static void cb_exit_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 7
+#if ASYNC_EXIT_DATA
+ || state == 107
+#endif
+ );
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_exit_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+static void cb_exit_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 8
+#if ASYNC_EXIT_DATA
+ || state == 108
+#endif
+ );
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_exit_data_start);
+
+ assert (prof_info->event_type == acc_ev_exit_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+static void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 0
+ || state == 100);
+ if (state == 100)
+ {
+ /* Compensate for the missing 'acc_ev_device_init_start' and
+ 'acc_ev_device_init_end'. */
+ state += 2;
+ }
+#else
+ if (state == 100)
+ {
+ /* Compensate for the missing 'acc_ev_device_init_start' and
+ 'acc_ev_device_init_end'. */
+ state += 2;
+ }
+ assert (state == 2
+ || state == 102);
+#endif
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing 'acc_ev_enter_data_start'. */
+ state += 1;
+ }
+}
+
+static void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing 'acc_ev_enter_data_end'. */
+ state += 1;
+ /* Compensate for the missing 'acc_ev_enqueue_launch_start' and
+ 'acc_ev_enqueue_launch_end'. */
+ state += 2;
+ /* Compensate for the missing 'acc_ev_exit_data_start' and
+ 'acc_ev_exit_data_end'. */
+ state += 2;
+ }
+#if !ASYNC_EXIT_DATA
+ else if (acc_async != acc_async_sync)
+ {
+ /* Compensate for the missing 'acc_ev_exit_data_start' and
+ 'acc_ev_exit_data_end'. */
+ state += 2;
+ }
+#endif
+ assert (state == 9
+ || state == 109);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+static void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 5
+ || state == 105);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == NULL);
+ assert (event_info->launch_event.kernel_name != NULL);
+ {
+ const char *s = strstr (event_info->launch_event.kernel_name, "main");
+ assert (s != NULL);
+ s = strstr (s, "omp_fn");
+ assert (s != NULL);
+ }
+ assert (event_info->launch_event.num_gangs >= 1);
+ assert (event_info->launch_event.num_workers >= 1);
+ assert (event_info->launch_event.vector_length >= 1);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.launch_event.event_type = event_info->launch_event.event_type;
+ tool_info->nested->event_info.launch_event.kernel_name = strdup (event_info->launch_event.kernel_name);
+ tool_info->nested->event_info.launch_event.num_gangs = event_info->launch_event.num_gangs;
+ tool_info->nested->event_info.launch_event.num_workers = event_info->launch_event.num_workers;
+ tool_info->nested->event_info.launch_event.vector_length = event_info->launch_event.vector_length;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+static void cb_enqueue_launch_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 6
+ || state == 106);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.launch_event.event_type == acc_ev_enqueue_launch_start);
+ assert (tool_info->nested->event_info.launch_event.kernel_name != NULL);
+ assert (tool_info->nested->event_info.launch_event.num_gangs >= 1);
+ assert (tool_info->nested->event_info.launch_event.num_workers >= 1);
+ assert (tool_info->nested->event_info.launch_event.vector_length >= 1);
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == tool_info->nested);
+ assert (event_info->launch_event.kernel_name != NULL);
+ assert (strcmp (event_info->launch_event.kernel_name, tool_info->nested->event_info.launch_event.kernel_name) == 0);
+ assert (event_info->launch_event.num_gangs == tool_info->nested->event_info.launch_event.num_gangs);
+ assert (event_info->launch_event.num_workers == tool_info->nested->event_info.launch_event.num_workers);
+ assert (event_info->launch_event.vector_length == tool_info->nested->event_info.launch_event.vector_length);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free ((void *) tool_info->nested->event_info.launch_event.kernel_name);
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_enter_data_start, cb_enter_data_start, acc_reg);
+ reg (acc_ev_enter_data_end, cb_enter_data_end, acc_reg);
+ reg (acc_ev_exit_data_start, cb_exit_data_start, acc_reg);
+ reg (acc_ev_exit_data_end, cb_exit_data_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
+ reg (acc_ev_enqueue_launch_end, cb_enqueue_launch_end, acc_reg);
+ assert (state == 0);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = acc_async_sync;
+ assert (state == 0);
+
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ asm volatile ("" : : : "memory"); // TODO PR90488
+
+ state_init = state;
+ }
+ assert (state_init == 4);
+ }
+ assert (state == 10);
+
+ STATE_OP (state, = 100);
+
+ acc_async = 12;
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ asm volatile ("" : : : "memory"); // TODO PR90488
+
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 104);
+ }
+ assert (state == 110);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
new file mode 100644
index 000000000000..5b58c51d4c42
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
@@ -0,0 +1,226 @@
+/* Test the 'valid_bytes' magic. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int ev_count_data;
+
+static void cb_data_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->data_event.valid_bytes == _ACC_DATA_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+
+ ++ev_count_data;
+}
+
+static int ev_count_launch;
+
+static void cb_launch_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+
+ ++ev_count_launch;
+}
+
+static int ev_count_other;
+
+static void cb_other_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+
+ ++ev_count_other;
+}
+
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_other_event, acc_reg);
+ reg_ (acc_ev_create, cb_data_event, acc_reg);
+ reg_ (acc_ev_delete, cb_data_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_data_event, acc_reg);
+ reg_ (acc_ev_free, cb_data_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_other_event, acc_reg);
+}
+
+
+/* Basic struct. */
+typedef struct A
+{
+ int a;
+ int b;
+#define VALID_BYTES_A \
+ _ACC_PROF_VALID_BYTES_STRUCT (A, b, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (int))
+} A;
+
+/* Add a 'char' field. */
+typedef struct B
+{
+ int a;
+ int b;
+ char c;
+#define VALID_BYTES_B \
+ _ACC_PROF_VALID_BYTES_STRUCT (B, c, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} B;
+
+/* Add another 'char' field. */
+typedef struct C
+{
+ int a;
+ int b;
+ char c, d;
+#define VALID_BYTES_C \
+ _ACC_PROF_VALID_BYTES_STRUCT (C, d, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} C;
+
+/* Add two 'void *' fields. */
+typedef struct D
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+#define VALID_BYTES_D \
+ _ACC_PROF_VALID_BYTES_STRUCT (D, f, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} D;
+
+/* Add another three 'char' fields. */
+typedef struct E
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+ char g, h, i;
+#define VALID_BYTES_E \
+ _ACC_PROF_VALID_BYTES_STRUCT (E, i, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} E;
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ A A1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof A1, VALID_BYTES_A);
+ assert (VALID_BYTES_A <= sizeof A1);
+ DEBUG_printf ("&A1=%p, &A1.b=%p\n", &A1, &A1.b);
+ assert (((char *) &A1) + VALID_BYTES_A == (char *) (&A1.b + 1));
+
+ B B1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof B1, VALID_BYTES_B);
+ assert (VALID_BYTES_B <= sizeof B1);
+ DEBUG_printf ("&B1=%p, &B1.c=%p\n", &B1, &B1.c);
+ assert (((char *) &B1) + VALID_BYTES_B == (char *) (&B1.c + 1));
+
+ assert (VALID_BYTES_B == VALID_BYTES_A + 1 * sizeof (char));
+
+ C C1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof C1, VALID_BYTES_C);
+ assert (VALID_BYTES_C <= sizeof C1);
+ DEBUG_printf ("&C1=%p, &C1.d=%p\n", &C1, &C1.d);
+ assert (((char *) &C1) + VALID_BYTES_C == (char *) (&C1.d + 1));
+
+ assert (VALID_BYTES_C == VALID_BYTES_B + 1 * sizeof (char));
+
+ D D1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof D1, VALID_BYTES_D);
+ assert (VALID_BYTES_D <= sizeof D1);
+ DEBUG_printf ("&D1=%p, &D1.f=%p\n", &D1, &D1.f);
+ assert (((char *) &D1) + VALID_BYTES_D == (char *) (&D1.f + 1));
+
+ assert (VALID_BYTES_D > VALID_BYTES_C);
+
+ E E1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof E1, VALID_BYTES_E);
+ assert (VALID_BYTES_E <= sizeof E1);
+ DEBUG_printf ("&E1=%p, &E1.i=%p\n", &E1, &E1.i);
+ assert (((char *) &E1) + VALID_BYTES_E == (char *) (&E1.i + 1));
+
+ assert (VALID_BYTES_E == VALID_BYTES_D + 3 * sizeof (char));
+
+ ev_count_data = 0;
+ ev_count_launch = 0;
+ ev_count_other = 0;
+
+ /* Trigger tests done in 'cb_*' functions. */
+ int host;
+#pragma acc parallel copyout (host)
+ {
+ asm volatile ("" : : : "memory"); // TODO PR90488
+
+ host = acc_on_device (acc_device_host);
+ }
+
+ DEBUG_printf ("ev_count_data = %d\n", ev_count_data);
+ if (host)
+ assert (ev_count_data == 0);
+ else
+ {
+ /* We don't know exactly how many data events to expect, but we at least
+ expect some. */
+ assert (ev_count_data > 0);
+ }
+
+ DEBUG_printf ("ev_count_launch = %d\n", ev_count_launch);
+ if (host)
+ assert (ev_count_data == 0);
+ else
+ {
+ /* We expect two launch events, 'acc_ev_enqueue_launch_start',
+ 'acc_ev_enqueue_launch_end'. */
+ assert (ev_count_launch == 2);
+ }
+
+ DEBUG_printf ("ev_count_other = %d\n", ev_count_other);
+ /* We don't know exactly how many other events to expect, but we at least
+ expect 'acc_ev_device_init_start', 'acc_ev_device_init_end',
+ 'acc_ev_compute_construct_start', 'acc_ev_compute_construct_end'. */
+ assert (ev_count_other >= 4);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
new file mode 100644
index 000000000000..f53786871671
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
@@ -0,0 +1,76 @@
+/* Test the 'version' field of 'acc_prof_info'. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int ev_count;
+
+
+static void cb_any_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->version == 201711);
+
+ ++ev_count;
+}
+
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_any_event, acc_reg);
+ reg_ (acc_ev_create, cb_any_event, acc_reg);
+ reg_ (acc_ev_delete, cb_any_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_any_event, acc_reg);
+ reg_ (acc_ev_free, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_any_event, acc_reg);
+}
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ ev_count = 0;
+
+ /* Trigger tests done in 'cb_*' functions. */
+#pragma acc parallel
+ {
+ asm volatile ("" : : : "memory"); // TODO PR90488
+ }
+
+ DEBUG_printf ("ev_count = %d\n", ev_count);
+ /* We don't know exactly how many events to expect, but we at least expect
+ 'acc_ev_device_init_start', 'acc_ev_device_init_end',
+ 'acc_ev_compute_construct_start', 'acc_ev_compute_construct_end'. */
+ assert (ev_count >= 4);
+
+ return 0;
+}
--
2.17.1
^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH, og9] Port OpenACC profiling interface to OG9
@ 2019-06-17 13:27 ` Kwok Cheung Yeung
2019-06-17 13:28 ` Kwok Cheung Yeung
0 siblings, 1 reply; 23+ messages in thread
From: Kwok Cheung Yeung @ 2019-06-17 13:27 UTC (permalink / raw)
To: Thomas Schwinge, gcc-patches; +Cc: Catherine Moore
[-- Attachment #1: Type: text/plain, Size: 431 bytes --]
Hello
This is a straightforward port of the OpenACC profiling interface from
OG8 to OG9, with a few tweaks to compensate for patches that have not
been carried over to OG9. I have also bundled in the profiling hooks and
documentation updates that have been added since the original patch in OG8.
This has been tested on x86_64 with no regressions on the libgomp testsuite.
Okay to push to openacc-gcc-9-branch?
Thanks
Kwok
[-- Attachment #2: 0001-OpenACC-2.6-Profiling-Interface.patch --]
[-- Type: text/plain, Size: 184046 bytes --]
From 8af550dcfc6c339e19293d59692cb595a2cb2d69 Mon Sep 17 00:00:00 2001
From: Thomas Schwinge <thomas@codesourcery.com>
Date: Tue, 28 Feb 2017 17:36:03 +0000
Subject: [PATCH] OpenACC 2.6 Profiling Interface
libgomp/
* acc_prof.h: New file.
* oacc-profiling-acc_register_library.c: Likewise.
* oacc-profiling.c: Likewise.
* Makefile.am (nodist_libsubinclude_HEADERS, libgomp_la_SOURCES):
Add these, respectively.
* Makefile.in: Regenerate.
* libgomp/config/nvptx/oacc-profiling-acc_register_library.c:
New empty file.
* libgomp/config/nvptx/oacc-profiling.c: Likewise.
* env.c (initialize_env): Call goacc_profiling_initialize.
* libgomp-plugin.c: New function
GOMP_PLUGIN_goacc_profiling_dispatch.
* libgomp-plugin.h: Declare function
GOMP_PLUGIN_goacc_profiling_dispatch.
* oacc-plugin.c: New function GOMP_PLUGIN_goacc_thread.
* oacc-plugin.h: Declare function GOMP_PLUGIN_goacc_thread.
* libgomp.map (OACC_2.5): Add acc_prof_lookup, acc_prof_register,
acc_prof_unregister, and acc_register_library.
Add GOMP_PLUGIN_goacc_profiling_dispatch, and
GOMP_PLUGIN_goacc_thread with new GOMP_PLUGIN_1.3 symbol version.
* oacc-int.h (struct goacc_thread): Add "acc_prof_info
*prof_info", "acc_api_info *api_info", and "bool
prof_callbacks_enabled" members.
Declare functions goacc_profiling_initialize,
goacc_profiling_dispatch_p, and goacc_profiling_dispatch.
* oacc-init.c (acc_init_1): Add "acc_construct_t", and "int"
formal parameters. Adjust all users.
(goacc_lazy_initialize): Don't call acc_init; copy code here,
instead.
(acc_init_1, goacc_attach_host_thread_to_device, acc_init)
(goacc_lazy_initialize): Update for OpenACC Profiling Interface.
* oacc-parallel.c (GOACC_parallel_keyed): Likewise.
* plugin/plugin-nvptx.c (cuda_map_create, cuda_map_destroy)
(map_init, map_fini, map_pop, map_push): Add "struct goacc_thread
*" formal parameter. Adjust all users.
(select_stream_for_async, event_gc, nvptx_exec, nvptx_host2dev)
(nvptx_dev2host, nvptx_set_cuda_stream): Call
GOMP_PLUGIN_goacc_thread instead of nvptx_thread.
(cuda_map_create, cuda_map_destroy, nvptx_exec, nvptx_alloc)
(nvptx_free, nvptx_host2dev, nvptx_dev2host): Update for OpenACC
Profiling Interface.
* libgomp.texi: New chapter "OpenACC Profiling Interface".
* testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c: New
file.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c: Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c:
Likewise.
libgomp/
* oacc-async.c (acc_async_test, acc_async_test_all, acc_wait)
(acc_wait_async, acc_wait_all, acc_wait_all_async): Set up
profiling.
* oacc-cuda.c (acc_get_current_cuda_device)
(acc_get_current_cuda_context, acc_get_cuda_stream)
(acc_set_cuda_stream): Likewise.
* oacc-init.c (acc_set_device_type, acc_get_device_type)
(acc_get_device_num): Likewise.
* oacc-mem.c (acc_malloc, acc_free, memcpy_tofrom_device)
(acc_map_data, acc_unmap_data, present_create_copy)
(delete_copyout, update_dev_host): Likewise.
* oacc-parallel.c (GOACC_data_start, GOACC_data_end)
(GOACC_enter_exit_data, GOACC_update, GOACC_wait): Likewise.
* oacc-profiling.c (goacc_profiling_setup_p): New function.
(goacc_profiling_dispatch_p): Add a "bool" formal parameter.
Adjust all users.
* oacc-int.h (goacc_profiling_setup_p)
(goacc_profiling_dispatch_p): Update.
* plugin/plugin-nvptx.c (nvptx_exec, nvptx_wait, nvptx_wait_all):
Generate more profiling events.
* libgomp.texi (OpenACC Environment Variables): Mention
"ACC_PROFLIB".
(OpenACC Profiling Interface): Update.
libgomp/
* oacc-init.c (get_property_any): Add profiling code.
libgomp/
* acc_prof.h (_ACC_PROF_INFO_VERSION): Update to 201711.
* libgomp.texi: Update mentions of OpenACC version to 2.6.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
(cb_any_event): Update expected profiling info version to 201711.
---
libgomp/ChangeLog.openacc | 96 +++
libgomp/Makefile.am | 3 +-
libgomp/Makefile.in | 14 +-
libgomp/acc_prof.h | 237 +++++++
.../nvptx/oacc-profiling-acc_register_library.c | 0
libgomp/config/nvptx/oacc-profiling.c | 0
libgomp/env.c | 2 +
libgomp/libgomp-plugin.c | 9 +
libgomp/libgomp-plugin.h | 6 +
libgomp/libgomp.map | 11 +
libgomp/libgomp.texi | 308 +++++++++
libgomp/oacc-async.c | 114 +++-
libgomp/oacc-cuda.c | 87 ++-
libgomp/oacc-init.c | 203 +++++-
libgomp/oacc-int.h | 14 +
libgomp/oacc-mem.c | 154 ++++-
libgomp/oacc-parallel.c | 475 +++++++++++++-
libgomp/oacc-plugin.c | 13 +
libgomp/oacc-plugin.h | 3 +
libgomp/oacc-profiling-acc_register_library.c | 39 ++
libgomp/oacc-profiling.c | 666 ++++++++++++++++++++
libgomp/plugin/plugin-nvptx.c | 178 ++++++
.../acc_prof-dispatch-1.c | 344 ++++++++++
.../libgomp.oacc-c-c++-common/acc_prof-init-1.c | 306 +++++++++
.../libgomp.oacc-c-c++-common/acc_prof-kernels-1.c | 253 ++++++++
.../acc_prof-parallel-1.c | 698 +++++++++++++++++++++
.../acc_prof-valid_bytes-1.c | 172 +++++
.../libgomp.oacc-c-c++-common/acc_prof-version-1.c | 55 ++
28 files changed, 4399 insertions(+), 61 deletions(-)
create mode 100644 libgomp/acc_prof.h
create mode 100644 libgomp/config/nvptx/oacc-profiling-acc_register_library.c
create mode 100644 libgomp/config/nvptx/oacc-profiling.c
create mode 100644 libgomp/oacc-profiling-acc_register_library.c
create mode 100644 libgomp/oacc-profiling.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
diff --git a/libgomp/ChangeLog.openacc b/libgomp/ChangeLog.openacc
index b3bcb31..bcca494 100644
--- a/libgomp/ChangeLog.openacc
+++ b/libgomp/ChangeLog.openacc
@@ -1,3 +1,99 @@
+2019-01-09 Julian Brown <julian@codesourcery.com>
+
+ * acc_prof.h (_ACC_PROF_INFO_VERSION): Update to 201711.
+ * libgomp.texi: Update mentions of OpenACC version to 2.6.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
+ (cb_any_event): Update expected profiling info version to 201711.
+
+2018-12-20 Maciej W. Rozycki <macro@codesourcery.com>
+
+ * oacc-init.c (get_property_any): Add profiling code.
+
+2017-05-15 Thomas Schwinge <thomas@codesourcery.com>
+
+ * oacc-async.c (acc_async_test, acc_async_test_all, acc_wait)
+ (acc_wait_async, acc_wait_all, acc_wait_all_async): Set up
+ profiling.
+ * oacc-cuda.c (acc_get_current_cuda_device)
+ (acc_get_current_cuda_context, acc_get_cuda_stream)
+ (acc_set_cuda_stream): Likewise.
+ * oacc-init.c (acc_set_device_type, acc_get_device_type)
+ (acc_get_device_num): Likewise.
+ * oacc-mem.c (acc_malloc, acc_free, memcpy_tofrom_device)
+ (acc_map_data, acc_unmap_data, present_create_copy)
+ (delete_copyout, update_dev_host): Likewise.
+ * oacc-parallel.c (GOACC_data_start, GOACC_data_end)
+ (GOACC_enter_exit_data, GOACC_update, GOACC_wait): Likewise.
+ * oacc-profiling.c (goacc_profiling_setup_p): New function.
+ (goacc_profiling_dispatch_p): Add a "bool" formal parameter.
+ Adjust all users.
+ * oacc-int.h (goacc_profiling_setup_p)
+ (goacc_profiling_dispatch_p): Update.
+ * plugin/plugin-nvptx.c (nvptx_exec, nvptx_wait, nvptx_wait_all):
+ Generate more profiling events.
+ * libgomp.texi (OpenACC Environment Variables): Mention
+ "ACC_PROFLIB".
+ (OpenACC Profiling Interface): Update.
+
+2017-05-14 Thomas Schwinge <thomas@codesourcery.com>
+
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-kernels-1.c: New
+ file.
+
+2017-02-28 Thomas Schwinge <thomas@codesourcery.com>
+
+ * acc_prof.h: New file.
+ * oacc-profiling-acc_register_library.c: Likewise.
+ * oacc-profiling.c: Likewise.
+ * Makefile.am (nodist_libsubinclude_HEADERS, libgomp_la_SOURCES):
+ Add these, respectively.
+ * Makefile.in: Regenerate.
+ * libgomp/config/nvptx/oacc-profiling-acc_register_library.c:
+ New empty file.
+ * libgomp/config/nvptx/oacc-profiling.c: Likewise.
+ * env.c (initialize_env): Call goacc_profiling_initialize.
+ * libgomp-plugin.c: New function
+ GOMP_PLUGIN_goacc_profiling_dispatch.
+ * libgomp-plugin.h: Declare function
+ GOMP_PLUGIN_goacc_profiling_dispatch.
+ * oacc-plugin.c: New function GOMP_PLUGIN_goacc_thread.
+ * oacc-plugin.h: Declare function GOMP_PLUGIN_goacc_thread.
+ * libgomp.map (OACC_2.5): Add acc_prof_lookup, acc_prof_register,
+ acc_prof_unregister, and acc_register_library.
+ Add GOMP_PLUGIN_goacc_profiling_dispatch, and
+ GOMP_PLUGIN_goacc_thread with new GOMP_PLUGIN_1.3 symbol version.
+ * oacc-int.h (struct goacc_thread): Add "acc_prof_info
+ *prof_info", "acc_api_info *api_info", and "bool
+ prof_callbacks_enabled" members.
+ Declare functions goacc_profiling_initialize,
+ goacc_profiling_dispatch_p, and goacc_profiling_dispatch.
+ * oacc-init.c (acc_init_1): Add "acc_construct_t", and "int"
+ formal parameters. Adjust all users.
+ (goacc_lazy_initialize): Don't call acc_init; copy code here,
+ instead.
+ (acc_init_1, goacc_attach_host_thread_to_device, acc_init)
+ (goacc_lazy_initialize): Update for OpenACC Profiling Interface.
+ * oacc-parallel.c (GOACC_parallel_keyed): Likewise.
+ * plugin/plugin-nvptx.c (cuda_map_create, cuda_map_destroy)
+ (map_init, map_fini, map_pop, map_push): Add "struct goacc_thread
+ *" formal parameter. Adjust all users.
+ (select_stream_for_async, event_gc, nvptx_exec, nvptx_host2dev)
+ (nvptx_dev2host, nvptx_set_cuda_stream): Call
+ GOMP_PLUGIN_goacc_thread instead of nvptx_thread.
+ (cuda_map_create, cuda_map_destroy, nvptx_exec, nvptx_alloc)
+ (nvptx_free, nvptx_host2dev, nvptx_dev2host): Update for OpenACC
+ Profiling Interface.
+ * libgomp.texi: New chapter "OpenACC Profiling Interface".
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-dispatch-1.c: New
+ file.
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-init-1.c: Likewise.
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-parallel-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-valid_bytes-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-version-1.c:
+ Likewise.
+
2019-05-28 Julian Brown <julian@codesourcery.com>
* testsuite/libgomp.oacc-fortran/gangprivate-attrib-2.f90: New test.
diff --git a/libgomp/Makefile.am b/libgomp/Makefile.am
index 2db3865..a38b66ef 100644
--- a/libgomp/Makefile.am
+++ b/libgomp/Makefile.am
@@ -72,6 +72,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c error.c \
proc.c sem.c bar.c ptrlock.c time.c fortran.c affinity.c target.c \
splay-tree.c libgomp-plugin.c oacc-parallel.c oacc-host.c oacc-init.c \
oacc-mem.c oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
+ oacc-profiling.c oacc-profiling-acc_register_library.c \
affinity-fmt.c teams.c
include $(top_srcdir)/plugin/Makefrag.am
@@ -81,7 +82,7 @@ libgomp_la_SOURCES += openacc.f90
endif
nodist_noinst_HEADERS = libgomp_f.h
-nodist_libsubinclude_HEADERS = omp.h openacc.h
+nodist_libsubinclude_HEADERS = acc_prof.h omp.h openacc.h
if USE_FORTRAN
nodist_finclude_HEADERS = omp_lib.h omp_lib.f90 omp_lib.mod omp_lib_kinds.mod \
openacc_lib.h openacc.f90 openacc.mod openacc_kinds.mod
diff --git a/libgomp/Makefile.in b/libgomp/Makefile.in
index 820a576..d81e3d8 100644
--- a/libgomp/Makefile.in
+++ b/libgomp/Makefile.in
@@ -16,7 +16,7 @@
# Plugins for offload execution, Makefile.am fragment.
#
-# Copyright (C) 2014-2018 Free Software Foundation, Inc.
+# Copyright (C) 2014-2019 Free Software Foundation, Inc.
#
# Contributed by Mentor Embedded.
#
@@ -215,8 +215,9 @@ am_libgomp_la_OBJECTS = alloc.lo atomic.lo barrier.lo critical.lo \
sem.lo bar.lo ptrlock.lo time.lo fortran.lo affinity.lo \
target.lo splay-tree.lo libgomp-plugin.lo oacc-parallel.lo \
oacc-host.lo oacc-init.lo oacc-mem.lo oacc-async.lo \
- oacc-plugin.lo oacc-cuda.lo priority_queue.lo affinity-fmt.lo \
- teams.lo $(am__objects_1)
+ oacc-plugin.lo oacc-cuda.lo priority_queue.lo \
+ oacc-profiling.lo oacc-profiling-acc_register_library.lo \
+ affinity-fmt.lo teams.lo $(am__objects_1)
libgomp_la_OBJECTS = $(am_libgomp_la_OBJECTS)
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
@@ -524,7 +525,7 @@ search_path = $(addprefix $(top_srcdir)/config/, $(config_path)) $(top_srcdir) \
fincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)$(MULTISUBDIR)/finclude
libsubincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)/include
-libgomp_la_LIBADD = $(LIBFFI)
+@USE_LIBFFI_TRUE@libgomp_la_LIBADD = $(LIBFFI)
AM_CPPFLAGS = $(addprefix -I, $(search_path)) $(LIBFFIINCS)
AM_CFLAGS = $(XCFLAGS)
AM_LDFLAGS = $(XLDFLAGS) $(SECTION_LDFLAGS) $(OPT_LDFLAGS)
@@ -553,6 +554,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c \
affinity.c target.c splay-tree.c libgomp-plugin.c \
oacc-parallel.c oacc-host.c oacc-init.c oacc-mem.c \
oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
+ oacc-profiling.c oacc-profiling-acc_register_library.c \
affinity-fmt.c teams.c $(am__append_3)
# Nvidia PTX OpenACC plugin.
@@ -577,7 +579,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c \
@PLUGIN_HSA_TRUE@libgomp_plugin_hsa_la_LIBADD = libgomp.la $(PLUGIN_HSA_LIBS)
@PLUGIN_HSA_TRUE@libgomp_plugin_hsa_la_LIBTOOLFLAGS = --tag=disable-static
nodist_noinst_HEADERS = libgomp_f.h
-nodist_libsubinclude_HEADERS = omp.h openacc.h
+nodist_libsubinclude_HEADERS = acc_prof.h omp.h openacc.h
@USE_FORTRAN_TRUE@nodist_finclude_HEADERS = omp_lib.h omp_lib.f90 omp_lib.mod omp_lib_kinds.mod \
@USE_FORTRAN_TRUE@ openacc_lib.h openacc.f90 openacc.mod openacc_kinds.mod
@@ -755,6 +757,8 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-mem.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-parallel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-plugin.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-profiling-acc_register_library.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-profiling.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ordered.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/parallel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/priority_queue.Plo@am__quote@
diff --git a/libgomp/acc_prof.h b/libgomp/acc_prof.h
new file mode 100644
index 0000000..fd11d4b
--- /dev/null
+++ b/libgomp/acc_prof.h
@@ -0,0 +1,237 @@
+/* OpenACC Runtime Library: Profiling Interface
+
+ Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+#ifndef _ACC_PROF_H
+#define _ACC_PROF_H 1
+
+/* The OpenACC standard doesn't say so explicitly, but as its Profiling
+ Interface makes use of, for example, <openacc.h>'s acc_device_t, we
+ supposedly are to #include that file here. */
+#include <openacc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.1. Events. */
+
+typedef enum acc_event_t
+{
+ acc_ev_none = 0,
+ acc_ev_device_init_start,
+ acc_ev_device_init_end,
+ acc_ev_device_shutdown_start,
+ acc_ev_device_shutdown_end,
+ acc_ev_runtime_shutdown,
+ acc_ev_create,
+ acc_ev_delete,
+ acc_ev_alloc,
+ acc_ev_free,
+ acc_ev_enter_data_start,
+ acc_ev_enter_data_end,
+ acc_ev_exit_data_start,
+ acc_ev_exit_data_end,
+ acc_ev_update_start,
+ acc_ev_update_end,
+ acc_ev_compute_construct_start,
+ acc_ev_compute_construct_end,
+ acc_ev_enqueue_launch_start,
+ acc_ev_enqueue_launch_end,
+ acc_ev_enqueue_upload_start,
+ acc_ev_enqueue_upload_end,
+ acc_ev_enqueue_download_start,
+ acc_ev_enqueue_download_end,
+ acc_ev_wait_start,
+ acc_ev_wait_end,
+ acc_ev_last
+} acc_event_t;
+
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.2. Callbacks Signature. */
+
+//TODO
+/* 'In all cases, a datatype of "size_t" means a 32-bit integer for a 32-bit
+ binary and a 64-bit integer for a 64-bit binary, and a datatype "int" means
+ a 32-bit integer for both 32-bit and 64-bit binaries'. */
+typedef long int _acc_prof_size_t;
+typedef int _acc_prof_int_t;
+
+/* Internal helpers: a struct's "valid_bytes" may be less than its "sizeof". */
+#define _ACC_PROF_VALID_BYTES_STRUCT(_struct, _lastfield, _valid_bytes_lastfield) \
+ offsetof (_struct, _lastfield) + (_valid_bytes_lastfield)
+#if 0 /* Untested. */
+#define _ACC_PROF_VALID_BYTES_TYPE_N(_type, _n, _valid_bytes_type) \
+ ((_n - 1) * sizeof (_type) + (_valid_bytes_type))
+#endif
+#define _ACC_PROF_VALID_BYTES_BASICTYPE(_basictype) \
+ (sizeof (_basictype))
+
+typedef struct acc_prof_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ _acc_prof_int_t version;
+ acc_device_t device_type;
+ _acc_prof_int_t device_number;
+ _acc_prof_int_t thread_id;
+ _acc_prof_size_t async;
+ _acc_prof_size_t async_queue;
+ char *src_file;
+ char *func_name;
+ _acc_prof_int_t line_no, end_line_no;
+ _acc_prof_int_t func_line_no, func_end_line_no;
+#define _ACC_PROF_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_prof_info, func_end_line_no, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_int_t))
+} acc_prof_info;
+
+/* We implement the OpenACC 2.6 Profiling Interface. */
+#define _ACC_PROF_INFO_VERSION 201711
+
+typedef enum acc_construct_t
+{
+ acc_construct_parallel = 0,
+ acc_construct_kernels,
+ acc_construct_loop,
+ acc_construct_data,
+ acc_construct_enter_data,
+ acc_construct_exit_data,
+ acc_construct_host_data,
+ acc_construct_atomic,
+ acc_construct_declare,
+ acc_construct_init,
+ acc_construct_shutdown,
+ acc_construct_set,
+ acc_construct_update,
+ acc_construct_routine,
+ acc_construct_wait,
+ acc_construct_runtime_api
+} acc_construct_t;
+
+typedef struct acc_data_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ char *var_name;
+ _acc_prof_size_t bytes;
+ void *host_ptr;
+ void *device_ptr;
+#define _ACC_DATA_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_data_event_info, device_ptr, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_data_event_info;
+
+typedef struct acc_launch_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ char *kernel_name;
+ _acc_prof_size_t num_gangs, num_workers, vector_length;
+#define _ACC_LAUNCH_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_launch_event_info, vector_length, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_size_t))
+} acc_launch_event_info;
+
+typedef struct acc_other_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+#define _ACC_OTHER_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_other_event_info, tool_info, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_other_event_info;
+
+typedef union acc_event_info
+{
+ acc_event_t event_type;
+ acc_data_event_info data_event;
+ acc_launch_event_info launch_event;
+ acc_other_event_info other_event;
+} acc_event_info;
+
+//TODO: should these relate to acc_device_t values?
+typedef enum acc_device_api
+{
+ acc_device_api_none = 0,
+ acc_device_api_cuda,
+ acc_device_api_opencl,
+ acc_device_api_coi,
+ acc_device_api_other
+} acc_device_api;
+
+typedef struct acc_api_info
+{
+ acc_device_api device_api;
+ _acc_prof_int_t valid_bytes;
+ acc_device_t device_type;
+ _acc_prof_int_t vendor;
+ void *device_handle;
+ void *context_handle;
+ void *async_handle;
+#define _ACC_API_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_api_info, async_handle, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_api_info;
+
+typedef void (*acc_prof_callback) (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.3. Loading the Library. */
+
+typedef enum acc_register_t
+{
+ acc_reg = 0,
+ acc_toggle = 1,
+ acc_toggle_per_thread = 2
+} acc_register_t;
+
+typedef void (*acc_prof_reg) (acc_event_t, acc_prof_callback, acc_register_t);
+extern void acc_prof_register (acc_event_t, acc_prof_callback, acc_register_t) __GOACC_NOTHROW;
+extern void acc_prof_unregister (acc_event_t, acc_prof_callback, acc_register_t) __GOACC_NOTHROW;
+typedef void (*acc_query_fn) ();
+typedef acc_query_fn (*acc_prof_lookup_func) (const char *);
+extern acc_query_fn acc_prof_lookup (const char *) __GOACC_NOTHROW;
+/* Don't tag "acc_register_library" as "__GOACC_NOTHROW": this function can be
+ overridden by the application, and must be expected to do "everything". */
+extern void acc_register_library (acc_prof_reg, acc_prof_reg, acc_prof_lookup_func);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ACC_PROF_H */
diff --git a/libgomp/config/nvptx/oacc-profiling-acc_register_library.c b/libgomp/config/nvptx/oacc-profiling-acc_register_library.c
new file mode 100644
index 0000000..e69de29
diff --git a/libgomp/config/nvptx/oacc-profiling.c b/libgomp/config/nvptx/oacc-profiling.c
new file mode 100644
index 0000000..e69de29
diff --git a/libgomp/env.c b/libgomp/env.c
index 7937fbb..29d9f58 100644
--- a/libgomp/env.c
+++ b/libgomp/env.c
@@ -1425,5 +1425,7 @@ initialize_env (void)
parse_gomp_openacc_dim ();
goacc_runtime_initialize ();
+
+ goacc_profiling_initialize ();
}
#endif /* LIBGOMP_OFFLOADED_ONLY */
diff --git a/libgomp/libgomp-plugin.c b/libgomp/libgomp-plugin.c
index 5b77a53..f9f77b1 100644
--- a/libgomp/libgomp-plugin.c
+++ b/libgomp/libgomp-plugin.c
@@ -29,6 +29,7 @@
#include <stdlib.h>
#include "libgomp.h"
+#include "oacc-int.h"
#include "libgomp-plugin.h"
void *
@@ -78,3 +79,11 @@ GOMP_PLUGIN_fatal (const char *msg, ...)
gomp_vfatal (msg, ap);
va_end (ap);
}
+
+void
+GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *prof_info,
+ acc_event_info *event_info,
+ acc_api_info *api_info)
+{
+ goacc_profiling_dispatch (prof_info, event_info, api_info);
+}
diff --git a/libgomp/libgomp-plugin.h b/libgomp/libgomp-plugin.h
index da8ce26..81819db 100644
--- a/libgomp/libgomp-plugin.h
+++ b/libgomp/libgomp-plugin.h
@@ -33,6 +33,8 @@
#include <stddef.h>
#include <stdint.h>
+#include "acc_prof.h"
+
#ifdef __cplusplus
extern "C" {
#endif
@@ -95,6 +97,10 @@ extern void GOMP_PLUGIN_error (const char *, ...)
extern void GOMP_PLUGIN_fatal (const char *, ...)
__attribute__ ((noreturn, format (printf, 1, 2)));
+extern void GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *,
+ acc_event_info *,
+ acc_api_info *);
+
/* Prototypes for functions implemented by libgomp plugins. */
extern const char *GOMP_OFFLOAD_get_name (void);
extern unsigned int GOMP_OFFLOAD_get_caps (void);
diff --git a/libgomp/libgomp.map b/libgomp/libgomp.map
index 717ae66..d07f4fe 100644
--- a/libgomp/libgomp.map
+++ b/libgomp/libgomp.map
@@ -466,6 +466,10 @@ OACC_2.5 {
acc_delete_finalize_async_array_h_;
acc_memcpy_from_device_async;
acc_memcpy_to_device_async;
+ acc_prof_lookup;
+ acc_prof_register;
+ acc_prof_unregister;
+ acc_register_library;
acc_update_device_async;
acc_update_device_async_32_h_;
acc_update_device_async_64_h_;
@@ -536,3 +540,10 @@ GOMP_PLUGIN_1.2 {
global:
GOMP_PLUGIN_acc_default_dim;
} GOMP_PLUGIN_1.1;
+
+# TODO
+GOMP_PLUGIN_1.3 {
+ global:
+ GOMP_PLUGIN_goacc_profiling_dispatch;
+ GOMP_PLUGIN_goacc_thread;
+} GOMP_PLUGIN_1.2;
diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi
index 7538846..25c17e0 100644
--- a/libgomp/libgomp.texi
+++ b/libgomp/libgomp.texi
@@ -111,6 +111,7 @@ changed to GNU Offloading and Multi Processing Runtime Library.
asynchronous operations.
* OpenACC Library Interoperability:: OpenACC library interoperability with the
NVIDIA CUBLAS library.
+* OpenACC Profiling Interface::
* The libgomp ABI:: Notes on the external ABI presented by libgomp.
* Reporting Bugs:: How to report bugs in the GNU Offloading and
Multi Processing Runtime Library.
@@ -2874,11 +2875,14 @@ A.2.1.4.
The variables @env{ACC_DEVICE_TYPE} and @env{ACC_DEVICE_NUM}
are defined by section 4 of the OpenACC specification in version 2.6.
+The variable @code{ACC_PROFLIB} is defined by section 4 of the OpenACC
+specification in version 2.6.
The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
@menu
* ACC_DEVICE_TYPE::
* ACC_DEVICE_NUM::
+* ACC_PROFLIB::
* GCC_ACC_NOTIFY::
@end menu
@@ -2904,6 +2908,19 @@ The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
+@node ACC_PROFLIB
+@section @code{ACC_PROFLIB}
+@table @asis
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+4.3.
+@end table
+
+
+
@node GCC_ACC_NOTIFY
@section @code{GCC_ACC_NOTIFY}
@table @asis
@@ -3120,6 +3137,297 @@ Application Programming Interface”, Version 2.6.}
@c ---------------------------------------------------------------------
+@c OpenACC Profiling Interface
+@c ---------------------------------------------------------------------
+
+@node OpenACC Profiling Interface
+@chapter OpenACC Profiling Interface
+
+@section Implementation Status and Implementation-Defined Behavior
+
+We're implementing most of the Profiling Interface as defined by
+the OpenACC 2.6 specification. The specification doesn't
+clearly define some aspects of its Profiling Interface, so we're
+clarifying these as @emph{implementation-defined behavior} here. We
+already have reported to the OpenACC Technical Committee some issues,
+and will report more, later on.
+
+This implementation of the OpenACC Profiling Interface is tuned to
+keep the performance impact as low as possible when it's not in use.
+This is relevant, as the Profiling Interface affects all the
+@emph{hot} code paths (in the target code, not in the offloaded code).
+Users of the OpenACC Profiling Interface can be expected to understand
+that performance will always be impacted to some degree: for example,
+because of the @emph{runtime} (libgomp) calling into a third-party
+@emph{library} for every event that has been registered.
+
+This implementation of the OpenACC Profiling Interface has not yet
+been validated for use in multi-threaded code. This is a more general
+issue; see CSTS-110 @cite{Make sure all OpenACC entry points in
+libgomp are thread-safe}.
+
+The @code{acc_prof_lookup} interface is not implemented, and
+@code{acc_register_library} will receive @code{NULL} for its
+@code{lookup} parameter.
+
+Remarks about data provided to callbacks:
+
+@table @asis
+
+@item @code{acc_prof_info.event_type}
+It is not clear if for @emph{nested} event callbacks (for example,
+@code{acc_ev_enqueue_launch_start} as part of a parent compute
+construct), this should be set for the nested event
+(@code{acc_ev_enqueue_launch_start}), or if the value of the parent
+construct should remain (@code{acc_ev_compute_construct_start}). In
+this implementation, the value will generally correspond to the
+innermost nested event type.
+
+@item @code{acc_prof_info.device_type}
+@itemize
+
+@item
+For @code{acc_ev_compute_construct_start}, and in presence of an
+@code{if} clause with @emph{false} argument, this will still refer to
+the offloading device type; unsure whether that's the expected
+behavior.
+
+@item
+Complementary to the item before, for
+@code{acc_ev_compute_construct_end}, this is set to
+@code{acc_device_host} in presence of an @code{if} clause with
+@emph{false} argument, unsure whether that's the expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.thread_id}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.async}
+@itemize
+
+@item
+Not yet implemented correctly for
+@code{acc_ev_compute_construct_start}.
+
+@item
+In a compute construct, for host-fallback
+execution/@code{acc_device_host} it will always be
+@code{acc_async_sync}; unsure if that is the expected behavior.
+
+@item
+For @code{acc_ev_device_init_start} and @code{acc_ev_device_init_end},
+it will always be @code{acc_async_sync}; unsure if that is the
+expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.async_queue}
+There is no @cite{limited number of asynchronous queues} in libgomp.
+We define this to always have the same value as
+@code{acc_prof_info.async}.
+
+@item @code{acc_prof_info.file}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_prof_info.func_name}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_prof_info.line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_event_info.event_type}, @code{acc_event_info.*.event_type}
+Relating to @code{acc_prof_info.event_type} discussed above, in this
+implementation, this will always be the same value as
+@code{acc_prof_info.event_type}.
+
+@item @code{acc_event_info.*.parent_construct}
+@itemize
+
+@item
+Will be @code{acc_construct_parallel} for OpenACC kernels constructs;
+should be @code{acc_construct_kernels}.
+
+@item
+Will be @code{acc_construct_enter_data} or
+@code{acc_construct_exit_data} when processing variable mappings
+specified in OpenACC declare directives; should be
+@code{acc_construct_declare}.
+
+@item
+For implicit @code{acc_ev_device_init_start},
+@code{acc_ev_device_init_end}, and explicit as well as implicit
+@code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start},
+@code{acc_ev_enqueue_download_end}, @code{acc_ev_wait_start}, and
+@code{acc_ev_wait_end}, will be
+@code{acc_construct_parallel}; should reflect the real parent
+construct.
+
+@end itemize
+
+@item @code{acc_event_info.*.implicit}
+For @code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start},
+@code{acc_ev_enqueue_download_end}, @code{acc_ev_wait_start}, and
+@code{acc_ev_wait_end}, this currently will be @code{1}
+also for explicit usage.
+
+@item @code{acc_event_info.data_event.var_name}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_event_info.data_event.host_ptr}
+For @code{acc_ev_alloc}, and @code{acc_ev_free}, this is always
+@code{NULL}.
+
+@item @code{typedef union acc_api_info}
+@dots{} as printed in @cite{5.2.3. Third Argument: API-Specific
+Information}, should obviously be @code{typedef @emph{struct}
+acc_api_info}.
+
+@item @code{acc_api_info.device_api}
+Possibly not yet implemented correctly for
+@code{acc_ev_compute_construct_start},
+@code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}:
+will always be @code{acc_device_api_none} for these event types.
+For @code{acc_ev_enter_data_start}, it will be
+@code{acc_device_api_none} in some cases.
+
+@item @code{acc_api_info.device_type}
+Always the same as @code{acc_prof_info.device_type}.
+
+@item @code{acc_api_info.vendor}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_api_info.device_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.context_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.async_handle}
+Always @code{NULL}; not yet implemented.
+
+@end table
+
+Remarks about certain event types:
+
+@table @asis
+
+@item @code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}
+@itemize
+
+@item
+@c See DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT in
+@c libgomp.oacc-c-c++-common/acc_prof-parallel-1.c.
+Whan a compute construct triggers implicit
+@code{acc_ev_device_init_start} and @code{acc_ev_device_init_end}
+events, they currently aren't @emph{nested within} the corresponding
+@code{acc_ev_compute_construct_start} and
+@code{acc_ev_compute_construct_end}, but they're currently observed
+@emph{before} @code{acc_ev_compute_construct_start}. It is not clear
+what to do: the standard asks us provide a lot of details to the
+@code{acc_ev_compute_construct_start} callback, without (implicitly)
+initializing a device before?
+
+@item
+Callbacks for these event types will not be invoked for calls to the
+@code{acc_set_device_type} and @code{acc_set_device_num} functions;
+it's not clear if they should be.
+
+@end itemize
+
+@item @code{acc_ev_enter_data_start}, @code{acc_ev_enter_data_end}, @code{acc_ev_exit_data_start}, @code{acc_ev_exit_data_end}
+@itemize
+
+@item
+Callbacks for these event types will also be invoked for OpenACC
+host_data constructs; it's not clear if they should be.
+
+@item
+Callbacks for these event types will also be invoked when processing
+variable mappings specified in OpenACC declare directives; it's not
+clear if they should be.
+
+@end itemize
+
+@end table
+
+Callbacks for the following event types will be invoked, but dispatch
+and information provided therein has not yet been thoroughly reviewed:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@item @code{acc_ev_update_start}, @code{acc_ev_update_end}
+@item @code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end}
+@item @code{acc_ev_enqueue_download_start}, @code{acc_ev_enqueue_download_end}
+@item @code{acc_ev_wait_start}, @code{acc_ev_wait_end}
+@end itemize
+
+During device initialization, and finalization, respectively,
+callbacks for the following event types will not yet be invoked:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@end itemize
+
+Callbacks for the following event types have not yet been implemented,
+so currently won't be invoked:
+
+@itemize
+@item @code{acc_ev_device_shutdown_start}, @code{acc_ev_device_shutdown_end}
+@item @code{acc_ev_runtime_shutdown}
+@item @code{acc_ev_create}, @code{acc_ev_delete}
+@end itemize
+
+For the following runtime library functions, not all expected
+callbacks will be invoked (mostly concerning implicit device
+initialization):
+
+@itemize
+@item @code{acc_get_num_devices}
+@item @code{acc_set_device_type}
+@item @code{acc_get_device_type}
+@item @code{acc_set_device_num}
+@item @code{acc_get_device_num}
+@item @code{acc_init}
+@item @code{acc_shutdown}
+@end itemize
+
+Aside from implicit device initialization, for the following runtime
+library functions, no callbacks will be invoked for shared-memory
+offloading devices (it's not clear if they should be):
+
+@itemize
+@item @code{acc_malloc}
+@item @code{acc_free}
+@item @code{acc_copyin}, @code{acc_present_or_copyin}, @code{acc_copyin_async}
+@item @code{acc_create}, @code{acc_present_or_create}, @code{acc_create_async}
+@item @code{acc_copyout}, @code{acc_copyout_async}
+@item @code{acc_delete}, @code{acc_delete_async}
+@item @code{acc_update_device}, @code{acc_update_device_async}
+@item @code{acc_update_self}, @code{acc_update_self_async}
+@item @code{acc_map_data}, @code{acc_unmap_data}
+@item @code{acc_memcpy_to_device}, @code{acc_memcpy_to_device_async}
+@item @code{acc_memcpy_from_device}, @code{acc_memcpy_from_device_async}
+@end itemize
+
+
+
+@c ---------------------------------------------------------------------
@c The libgomp ABI
@c ---------------------------------------------------------------------
diff --git a/libgomp/oacc-async.c b/libgomp/oacc-async.c
index 51bb676..bf56560 100644
--- a/libgomp/oacc-async.c
+++ b/libgomp/oacc-async.c
@@ -125,7 +125,7 @@ lookup_goacc_asyncqueue (struct goacc_thread *thr, bool create, int async)
ret_aq = dev->openacc.async.asyncqueue[async];
- end:
+end:
gomp_mutex_unlock (&dev->openacc.async.lock);
return ret_aq;
}
@@ -149,11 +149,30 @@ acc_async_test (int async)
if (!thr || !thr->dev)
gomp_fatal ("no device active");
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
- if (!aq)
- return 1;
- else
- return thr->dev->openacc.async.test_func (aq);
+ int res = 1;
+ if (aq)
+ res = thr->dev->openacc.async.test_func (aq);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return res;
}
int
@@ -161,6 +180,12 @@ acc_async_test_all (void)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
int ret = 1;
gomp_mutex_lock (&thr->dev->openacc.async.lock);
for (goacc_aq_list l = thr->dev->openacc.async.active; l; l = l->next)
@@ -170,6 +195,13 @@ acc_async_test_all (void)
break;
}
gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return ret;
}
@@ -178,9 +210,27 @@ acc_wait (int async)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
if (aq && !thr->dev->openacc.async.synchronize_func (aq))
gomp_fatal ("wait on %d failed", async);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
/* acc_async_wait is an OpenACC 1.0 compatibility name for acc_wait. */
@@ -199,16 +249,28 @@ acc_wait_async (int async1, int async2)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async2; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq1 = lookup_goacc_asyncqueue (thr, false, async1);
/* TODO: Is this also correct for acc_async_sync, assuming that in this case,
we'll always be synchronous anyways? */
if (!aq1)
- return;
+ goto end;
goacc_aq aq2 = lookup_goacc_asyncqueue (thr, true, async2);
/* An async queue is always synchronized with itself. */
if (aq1 == aq2)
- return;
+ goto end;
if (aq2)
{
@@ -222,12 +284,26 @@ acc_wait_async (int async1, int async2)
if (!thr->dev->openacc.async.synchronize_func (aq1))
gomp_fatal ("wait on %d failed", async1);
}
+
+end:
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
acc_wait_all (void)
{
struct gomp_device_descr *dev = get_goacc_thread_device ();
+ struct goacc_thread *thr = goacc_thread ();
+
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
bool ret = true;
gomp_mutex_lock (&dev->openacc.async.lock);
@@ -237,6 +313,12 @@ acc_wait_all (void)
if (!ret)
gomp_fatal ("wait all failed");
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
/* acc_async_wait_all is an OpenACC 1.0 compatibility name for acc_wait_all. */
@@ -255,6 +337,18 @@ acc_wait_all_async (int async)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq waiting_queue = lookup_goacc_asyncqueue (thr, true, async);
bool ret = true;
@@ -272,6 +366,12 @@ acc_wait_all_async (int async)
if (!ret)
gomp_fatal ("wait all async(%d) failed", async);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
attribute_hidden void
diff --git a/libgomp/oacc-cuda.c b/libgomp/oacc-cuda.c
index 1ca7149..4ba0bb3 100644
--- a/libgomp/oacc-cuda.c
+++ b/libgomp/oacc-cuda.c
@@ -37,10 +37,23 @@ acc_get_current_cuda_device (void)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_device_func)
- return thr->dev->openacc.cuda.get_current_device_func ();
+ ret = thr->dev->openacc.cuda.get_current_device_func ();
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
- return NULL;
+ return ret;
}
void *
@@ -48,10 +61,23 @@ acc_get_current_cuda_context (void)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_context_func)
- return thr->dev->openacc.cuda.get_current_context_func ();
-
- return NULL;
+ ret = thr->dev->openacc.cuda.get_current_context_func ();
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return ret;
}
void *
@@ -62,14 +88,33 @@ acc_get_cuda_stream (int async)
if (!async_valid_p (async))
return NULL;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_stream_func)
{
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
if (aq)
- return thr->dev->openacc.cuda.get_stream_func (aq);
+ ret = thr->dev->openacc.cuda.get_stream_func (aq);
}
- return NULL;
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return ret;
}
/* As of OpenACC 2.6, the return code of this function appears to be
@@ -87,6 +132,18 @@ acc_set_cuda_stream (int async, void *stream)
thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
int ret = 0;
if (thr && thr->dev && thr->dev->openacc.cuda.set_stream_func)
{
@@ -98,11 +155,19 @@ acc_set_cuda_stream (int async, void *stream)
assert (async == acc_async_sync);
gomp_debug (0, "Refusing request to set CUDA stream associated"
" with \"acc_async_sync\"\n");
- return 0;
}
- gomp_mutex_lock (&thr->dev->openacc.async.lock);
- ret = thr->dev->openacc.cuda.set_stream_func (aq, stream);
- gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+ else
+ {
+ gomp_mutex_lock (&thr->dev->openacc.async.lock);
+ ret = thr->dev->openacc.cuda.set_stream_func (aq, stream);
+ gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+ }
+ }
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
}
return ret;
diff --git a/libgomp/oacc-init.c b/libgomp/oacc-init.c
index 0cd673e..57b3b87 100644
--- a/libgomp/oacc-init.c
+++ b/libgomp/oacc-init.c
@@ -228,8 +228,70 @@ acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)
held before calling this function. */
static struct gomp_device_descr *
-acc_init_1 (acc_device_t d)
+acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
{
+ bool check_not_nested_p;
+ if (implicit)
+ {
+ /* In the implicit case, there should (TODO: must?) already be something
+ have been set up for an outer construct. */
+ check_not_nested_p = false;
+ }
+ else
+ {
+ check_not_nested_p = true;
+ /* TODO: should we set "thr->prof_info" etc. in this case (acc_init)?
+ The problem is, that we don't have "thr" yet? (So,
+ "check_not_nested_p = true" also is pointless actually.) */
+ }
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (check_not_nested_p),
+ false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_device_init_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = d;
+ prof_info.device_number = goacc_device_num;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = acc_async_sync; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info device_init_event_info;
+ if (profiling_dispatch_p)
+ {
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ device_init_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ device_init_event_info.other_event.parent_construct = parent_construct;
+ device_init_event_info.other_event.implicit = implicit;
+ device_init_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ api_info.device_api = acc_device_api_none; //TODO
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info, &api_info);
+
struct gomp_device_descr *base_dev, *acc_dev;
int ndevs;
@@ -261,6 +323,14 @@ acc_init_1 (acc_device_t d)
acc_init_state = initialized;
gomp_mutex_unlock (&acc_init_state_lock);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_device_init_end;
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info,
+ &api_info);
+ }
+
return base_dev;
}
@@ -454,7 +524,11 @@ goacc_attach_host_thread_to_device (int ord)
thr->dev = acc_dev = &base_dev[ord];
thr->saved_bound_dev = NULL;
thr->mapped_data = NULL;
-
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ /* Initially, all callbacks for all events are enabled. */
+ thr->prof_callbacks_enabled = true;
+
thr->target_tls
= acc_dev->openacc.create_thread_data_func (ord);
}
@@ -468,9 +542,7 @@ acc_init (acc_device_t d)
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
-
- cached_base_dev = acc_init_1 (d);
-
+ cached_base_dev = acc_init_1 (d, acc_construct_runtime_api, 0);
gomp_mutex_unlock (&acc_device_lock);
goacc_attach_host_thread_to_device (-1);
@@ -495,11 +567,21 @@ ialias (acc_shutdown)
int
acc_get_num_devices (acc_device_t d)
{
+#if 0 //TODO
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ prof_info.device_type = d; //TODO
+#endif
+
int n = 0;
struct gomp_device_descr *acc_dev;
if (d == acc_device_none)
- return 0;
+ goto out;
gomp_init_targets_once ();
@@ -508,12 +590,21 @@ acc_get_num_devices (acc_device_t d)
gomp_mutex_unlock (&acc_device_lock);
if (!acc_dev)
- return 0;
+ goto out;
n = acc_dev->get_num_devices_func ();
if (n < 0)
n = 0;
+ out:
+#if 0 //TODO
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+#endif
+
return n;
}
@@ -529,6 +620,14 @@ acc_set_device_type (acc_device_t d)
struct gomp_device_descr *base_dev, *acc_dev;
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ prof_info.device_type = d; //TODO
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
@@ -553,6 +652,12 @@ acc_set_device_type (acc_device_t d)
}
goacc_attach_host_thread_to_device (-1);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
ialias (acc_set_device_type)
@@ -588,12 +693,25 @@ acc_get_device_type (void)
;
else
{
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr,
+ &prof_info, &api_info),
+ false);
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (acc_device_default, true);
gomp_mutex_unlock (&acc_device_lock);
res = acc_device_type (dev->type);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
assert (res != acc_device_default
@@ -611,6 +729,14 @@ acc_get_device_num (acc_device_t d)
const struct gomp_device_descr *dev;
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ prof_info.device_type = d; //TODO
+
if (d >= _ACC_device_hwm)
gomp_fatal ("unknown device type %u", (unsigned) d);
@@ -620,6 +746,12 @@ acc_get_device_num (acc_device_t d)
dev = resolve_device (d, true);
gomp_mutex_unlock (&acc_device_lock);
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
if (thr && thr->base_dev == dev && thr->dev)
return thr->dev->target_id;
@@ -631,6 +763,19 @@ ialias (acc_get_device_num)
void
acc_set_device_num (int ord, acc_device_t d)
{
+#if 0 //TODO
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.device_type = d; //TODO
+ prof_info.device_type = ord; //TODO
+ }
+#endif
+
struct gomp_device_descr *base_dev, *acc_dev;
int num_devices;
@@ -668,6 +813,14 @@ acc_set_device_num (int ord, acc_device_t d)
}
goacc_device_num = ord;
+
+#if 0 //TODO
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+#endif
}
ialias (acc_set_device_num)
@@ -688,14 +841,32 @@ get_property_any (int ord, acc_device_t d, acc_device_property_t prop)
if (d == acc_device_current && (!thr || !thr->dev))
return (union gomp_device_property_value) { .val = 0 };
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
if (d == acc_device_current)
{
+ if (profiling_setup_p)
+ {
+ prof_info.device_type = acc_device_type (thr->dev->type);
+ prof_info.device_number = thr->dev->target_id;
+ }
+
dev = thr->dev;
}
else
{
int num_devices;
+ if (profiling_setup_p)
+ {
+ prof_info.device_type = d;
+ prof_info.device_number = ord;
+ }
+
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (d, false);
@@ -719,6 +890,12 @@ get_property_any (int ord, acc_device_t d, acc_device_property_t prop)
propval = dev->get_property_func (dev->target_id, prop);
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return propval;
}
@@ -809,12 +986,16 @@ attribute_hidden void
goacc_lazy_initialize (void)
{
struct goacc_thread *thr = goacc_thread ();
-
if (thr && thr->dev)
return;
+ gomp_init_targets_once ();
+
+ gomp_mutex_lock (&acc_device_lock);
if (!cached_base_dev)
- acc_init (acc_device_default);
- else
- goacc_attach_host_thread_to_device (-1);
+ cached_base_dev = acc_init_1 (acc_device_default,
+ /* TODO */ acc_construct_parallel, 1);
+ gomp_mutex_unlock (&acc_device_lock);
+
+ goacc_attach_host_thread_to_device (-1);
}
diff --git a/libgomp/oacc-int.h b/libgomp/oacc-int.h
index e4b6ea6..980cf32 100644
--- a/libgomp/oacc-int.h
+++ b/libgomp/oacc-int.h
@@ -40,6 +40,7 @@
#include "openacc.h"
#include "config.h"
+#include "acc_prof.h"
#include <stddef.h>
#include <stdbool.h>
#include <stdarg.h>
@@ -68,6 +69,12 @@ struct goacc_thread
strictly push/pop semantics according to lexical scope. */
struct target_mem_desc *mapped_data;
+ /* Data of the OpenACC Profiling Interface. */
+ acc_prof_info *prof_info;
+ acc_api_info *api_info;
+ /* Per-thread toggle of OpenACC Profiling Interface callbacks. */
+ bool prof_callbacks_enabled;
+
/* These structures form a list: this is the next thread in that list. */
struct goacc_thread *next;
@@ -128,6 +135,13 @@ async_synchronous_p (int async)
return async == acc_async_sync;
}
+void goacc_profiling_initialize (void);
+bool goacc_profiling_setup_p (struct goacc_thread *,
+ acc_prof_info *, acc_api_info *);
+bool goacc_profiling_dispatch_p (bool);
+void goacc_profiling_dispatch (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+
#ifdef HAVE_ATTRIBUTE_VISIBILITY
# pragma GCC visibility pop
#endif
diff --git a/libgomp/oacc-mem.c b/libgomp/oacc-mem.c
index b3b3777..1922f38 100644
--- a/libgomp/oacc-mem.c
+++ b/libgomp/oacc-mem.c
@@ -99,12 +99,30 @@ acc_malloc (size_t s)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
assert (thr->dev);
+ void *ret;
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- return malloc (s);
+ {
+ /* TODO: Should we also generate acc_ev_alloc here? */
+ ret = malloc (s);
+ }
+ else
+ ret = thr->dev->alloc_func (thr->dev->target_id, s);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
- return thr->dev->alloc_func (thr->dev->target_id, s);
+ return ret;
}
/* OpenACC 2.0a (3.2.16) doesn't specify what to do in the event
@@ -120,12 +138,23 @@ acc_free (void *d)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
assert (thr && thr->dev);
struct gomp_device_descr *acc_dev = thr->dev;
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- return free (d);
+ {
+ /* TODO: Should we also generate acc_ev_free here? */
+ free (d);
+
+ goto out;
+ }
gomp_mutex_lock (&acc_dev->lock);
@@ -147,6 +176,13 @@ acc_free (void *d)
if (!acc_dev->free_func (acc_dev->target_id, d))
gomp_fatal ("error in freeing device memory in %s", __FUNCTION__);
+
+ out:
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
@@ -157,15 +193,31 @@ memcpy_tofrom_device (bool from, void *d, void *h, size_t s, int async,
been obtained from a routine that did that. */
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
assert (thr && thr->dev);
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
{
+ /* TODO: Should we also generate
+ acc_ev_enqueue_upload_start/acc_ev_enqueue_upload_end or
+ acc_ev_enqueue_download_start/acc_ev_enqueue_download_end here? */
if (from)
memmove (h, d, s);
else
memmove (d, h, s);
- return;
+
+ goto out;
}
goacc_aq aq = get_goacc_asyncqueue (async);
@@ -173,6 +225,13 @@ memcpy_tofrom_device (bool from, void *d, void *h, size_t s, int async,
gomp_copy_dev2host (thr->dev, aq, h, d, s);
else
gomp_copy_host2dev (thr->dev, aq, d, h, s, /* TODO: cbuf? */ NULL);
+
+out:
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -217,6 +276,9 @@ acc_deviceptr (void *h)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&dev->lock);
n = lookup_host (dev, h, 1);
@@ -254,6 +316,9 @@ acc_hostptr (void *d)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return d;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_dev (&acc_dev->mem_map, d, 1);
@@ -291,6 +356,9 @@ acc_is_present (void *h, size_t s)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h != NULL;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -322,6 +390,12 @@ acc_map_data (void *h, void *d, size_t s)
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
{
if (d != h)
@@ -357,6 +431,12 @@ acc_map_data (void *h, void *d, size_t s)
&kinds, true, GOMP_MAP_VARS_OPENACC);
tgt->list[0].key->refcount = REFCOUNT_INFINITY;
}
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -372,6 +452,12 @@ acc_unmap_data (void *h)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
gomp_mutex_lock (&acc_dev->lock);
cur_node.host_start = (uintptr_t) h;
@@ -405,6 +491,12 @@ acc_unmap_data (void *h)
}
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
#define FLAG_PRESENT (1 << 0)
@@ -428,6 +520,18 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -489,6 +593,12 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
gomp_mutex_unlock (&acc_dev->lock);
}
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return d;
}
@@ -569,6 +679,18 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -627,6 +749,12 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
}
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -700,6 +828,18 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
gomp_mutex_lock (&acc_dev->lock);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
n = lookup_host (acc_dev, h, s);
if (!n)
@@ -719,6 +859,12 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
gomp_copy_dev2host (acc_dev, aq, h, d, s);
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
diff --git a/libgomp/oacc-parallel.c b/libgomp/oacc-parallel.c
index b949599..670c62c 100644
--- a/libgomp/oacc-parallel.c
+++ b/libgomp/oacc-parallel.c
@@ -205,22 +205,81 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
thr = goacc_thread ();
acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_compute_construct_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info compute_construct_event_info;
+ if (profiling_dispatch_p)
+ {
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ compute_construct_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ compute_construct_event_info.other_event.parent_construct
+ = acc_construct_parallel; //TODO: kernels...
+ compute_construct_event_info.other_event.implicit = 0;
+ compute_construct_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds);
/* Host fallback if "if" clause is false or if the current device is set to
the host. */
if (flags & GOACC_FLAG_HOST_FALLBACK)
{
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
goacc_save_and_set_bind (acc_device_host);
goacc_call_host_fn (fn, mapnum, hostaddrs, params);
goacc_restore_bind ();
- return;
+ goto out;
}
else if (acc_device_type (acc_dev->type) == acc_device_host)
{
goacc_call_host_fn (fn, mapnum, hostaddrs, params);
- return;
+ goto out;
}
+ else if (profiling_dispatch_p)
+ api_info.device_api = acc_device_api_cuda;
/* Default: let the runtime choose. */
for (i = 0; i != GOMP_DIM_MAX; i++)
@@ -252,6 +311,14 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
if (async == GOMP_LAUNCH_OP_MAX)
async = va_arg (*ap, unsigned);
+
+ if (profiling_dispatch_p)
+ {
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
break;
}
@@ -284,10 +351,34 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
else
tgt_fn = (void (*)) fn;
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_start;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = compute_construct_event_info.other_event.parent_construct;
+ enter_exit_data_event_info.other_event.implicit = 1;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
+
goacc_aq aq = get_goacc_asyncqueue (async);
tgt = gomp_map_vars_async (acc_dev, aq, mapnum, hostaddrs, NULL, sizes, kinds,
true, GOMP_MAP_VARS_OPENACC);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
#ifdef RC_CHECKING
gomp_mutex_lock (&acc_dev->lock);
@@ -310,8 +401,25 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
else
acc_dev->openacc.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs,
dims, tgt);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_start;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
/* If running synchronously, unmap immediately. */
gomp_unmap_vars (tgt, true);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
}
else
{
@@ -329,6 +437,19 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
gomp_rc_check (acc_dev, thr->mapped_data);
gomp_mutex_unlock (&acc_dev->lock);
#endif
+
+out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_compute_construct_end;
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -390,6 +511,72 @@ GOACC_data_start (int flags_m, size_t mapnum,
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_enter_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info enter_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ enter_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_data_event_info.other_event.parent_construct = acc_construct_data;
+ for (int i = 0; i < mapnum; ++i)
+ if (kinds[i] == GOMP_MAP_USE_DEVICE_PTR)
+ {
+ /* If there is one such data mapping kind, then this is actually an
+ OpenACC host_data construct. (GCC maps the OpenACC host_data
+ construct to the OpenACC data construct.) Apart from artificial
+ test cases (such as an OpenACC host_data construct's (implicit)
+ device initialization when there hasn't been any device data be
+ set up before...), there can't really any meaningful events be
+ generated from OpenACC host_data constructs, though. */
+ enter_data_event_info.other_event.parent_construct
+ = acc_construct_host_data;
+ break;
+ }
+ enter_data_event_info.other_event.implicit = 0;
+ enter_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds);
enum gomp_map_vars_kind pragma_kind;
@@ -402,11 +589,14 @@ GOACC_data_start (int flags_m, size_t mapnum,
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| (flags & GOACC_FLAG_HOST_FALLBACK))
{
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
tgt = gomp_map_vars (NULL, 0, NULL, NULL, NULL, NULL, true, pragma_kind);
tgt->prev = thr->mapped_data;
thr->mapped_data = tgt;
- return;
+ goto out;
}
gomp_debug (0, " %s: prepare mappings\n", __FUNCTION__);
@@ -421,14 +611,78 @@ GOACC_data_start (int flags_m, size_t mapnum,
gomp_rc_check (acc_dev, thr->mapped_data);
gomp_mutex_unlock (&acc_dev->lock);
#endif
+
+out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_data_end (void)
{
struct goacc_thread *thr = goacc_thread ();
+ struct gomp_device_descr *acc_dev = thr->dev;
struct target_mem_desc *tgt = thr->mapped_data;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ exit_data_event_info.other_event.parent_construct = acc_construct_data;
+ exit_data_event_info.other_event.implicit = 0;
+ exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
gomp_debug (0, " %s: restore mappings\n", __FUNCTION__);
thr->mapped_data = tgt->prev;
gomp_unmap_vars (tgt, true);
@@ -439,6 +693,16 @@ GOACC_data_end (void)
gomp_rc_check (thr->dev, thr->mapped_data);
gomp_mutex_unlock (&thr->dev->lock);
#endif
+
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_end;
+ exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -453,24 +717,6 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
bool data_enter = false;
size_t i;
- goacc_lazy_initialize ();
-
- thr = goacc_thread ();
- acc_dev = thr->dev;
-
- if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- || (flags & GOACC_FLAG_HOST_FALLBACK))
- return;
-
- if (num_waits)
- {
- va_list ap;
-
- va_start (ap, num_waits);
- goacc_wait (async, num_waits, &ap);
- va_end (ap);
- }
-
/* Determine whether "finalize" semantics apply to all mappings of this
OpenACC directive. */
bool finalize = false;
@@ -521,6 +767,86 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
kind);
}
+ goacc_lazy_initialize ();
+
+ thr = goacc_thread ();
+ acc_dev = thr->dev;
+
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type
+ = data_enter ? acc_ev_enter_data_start : acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = data_enter ? acc_construct_enter_data : acc_construct_exit_data;
+ enter_exit_data_event_info.other_event.implicit = 0;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
+ || (flags & GOACC_FLAG_HOST_FALLBACK))
+ {
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+ goto out;
+ }
+
+ if (num_waits > 0)
+ {
+ va_list ap;
+
+ va_start (ap, num_waits);
+ goacc_wait (async, num_waits, &ap);
+ va_end (ap);
+ }
+ else if (num_waits == acc_async_noval)
+ acc_wait_all_async (async);
+
/* In c, non-pointers and arrays are represented by a single data clause.
Dynamically allocated arrays and subarrays are represented by a data
clause followed by an internal GOMP_MAP_POINTER.
@@ -739,6 +1065,18 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
gomp_rc_check (acc_dev, thr->mapped_data);
gomp_mutex_unlock (&acc_dev->lock);
#endif
+
+out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = data_enter ? acc_ev_enter_data_end: acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
@@ -787,9 +1125,66 @@ GOACC_update (int flags_m, size_t mapnum,
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_update_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info update_event_info;
+ if (profiling_dispatch_p)
+ {
+ update_event_info.other_event.event_type
+ = prof_info.event_type;
+ update_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ update_event_info.other_event.parent_construct = acc_construct_update;
+ update_event_info.other_event.implicit = 0;
+ update_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| (flags & GOACC_FLAG_HOST_FALLBACK))
- return;
+ {
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+ goto out;
+ }
if (num_waits)
{
@@ -861,11 +1256,41 @@ GOACC_update (int flags_m, size_t mapnum,
break;
}
}
+
+out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_update_end;
+ update_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_wait (int async, int num_waits, ...)
{
+ goacc_lazy_initialize ();
+
+ struct goacc_thread *thr = goacc_thread ();
+
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
if (num_waits)
{
va_list ap;
@@ -878,6 +1303,12 @@ GOACC_wait (int async, int num_waits, ...)
acc_wait_all ();
else
acc_wait_all_async (async);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
int
diff --git a/libgomp/oacc-plugin.c b/libgomp/oacc-plugin.c
index 5480c1d..a04abb0 100644
--- a/libgomp/oacc-plugin.c
+++ b/libgomp/oacc-plugin.c
@@ -47,6 +47,19 @@ GOMP_PLUGIN_acc_thread (void)
return thr ? thr->target_tls : NULL;
}
+/* Return the TLS data for the current thread. */
+/* TODO. Should we be able to directly call (the static inline function)
+ goacc_thread from within plugin code? I didn't manage to get the
+ "goacc_tls_data" symbol configured correctly: "[...]/ld:
+ .libs/libgomp-plugin-nvptx.so.1.0.0: hidden symbol `goacc_tls_data' isn't
+ defined". */
+
+struct goacc_thread *
+GOMP_PLUGIN_goacc_thread (void)
+{
+ return goacc_thread ();
+}
+
int
GOMP_PLUGIN_acc_default_dim (unsigned int i)
{
diff --git a/libgomp/oacc-plugin.h b/libgomp/oacc-plugin.h
index 112d4a59..112d3cd 100644
--- a/libgomp/oacc-plugin.h
+++ b/libgomp/oacc-plugin.h
@@ -27,8 +27,11 @@
#ifndef OACC_PLUGIN_H
#define OACC_PLUGIN_H 1
+#include "oacc-int.h"
+
extern void GOMP_PLUGIN_async_unmap_vars (void *, int);
extern void *GOMP_PLUGIN_acc_thread (void);
+extern struct goacc_thread *GOMP_PLUGIN_goacc_thread (void);
extern int GOMP_PLUGIN_acc_default_dim (unsigned int);
#endif
diff --git a/libgomp/oacc-profiling-acc_register_library.c b/libgomp/oacc-profiling-acc_register_library.c
new file mode 100644
index 0000000..f6b482b
--- /dev/null
+++ b/libgomp/oacc-profiling-acc_register_library.c
@@ -0,0 +1,39 @@
+/* Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+/* This file provides an stub acc_register_library function. It's in a
+ separate file so that this function can easily be overridden when linking
+ statically. */
+
+#include "libgomp.h"
+#include "acc_prof.h"
+
+void
+acc_register_library (acc_prof_reg reg, acc_prof_reg unreg,
+ acc_prof_lookup_func lookup)
+{
+ gomp_debug (0, "dummy %s\n", __FUNCTION__);
+}
diff --git a/libgomp/oacc-profiling.c b/libgomp/oacc-profiling.c
new file mode 100644
index 0000000..5542d6a
--- /dev/null
+++ b/libgomp/oacc-profiling.c
@@ -0,0 +1,666 @@
+/* Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+/* OpenACC Profiling Interface. */
+
+#include "libgomp.h"
+#include "oacc-int.h"
+#include "acc_prof.h"
+#include <assert.h>
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+#ifdef PLUGIN_SUPPORT
+# include <dlfcn.h>
+#endif
+
+#define STATIC_ASSERT(expr) _Static_assert (expr, "!(" #expr ")")
+
+/* Statically assert that the layout of the common fields in the
+ "acc_event_info" variants matches. */
+/* event_type */
+STATIC_ASSERT (offsetof (acc_event_info, event_type)
+ == offsetof (acc_event_info, data_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, launch_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, other_event.event_type));
+/* valid_bytes */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, launch_event.valid_bytes));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, other_event.valid_bytes));
+/* parent_construct */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, launch_event.parent_construct));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, other_event.parent_construct));
+/* implicit */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, launch_event.implicit));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, other_event.implicit));
+/* tool_info */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, launch_event.tool_info));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, other_event.tool_info));
+
+struct goacc_prof_callback_entry
+{
+ acc_prof_callback cb;
+ int ref;
+ bool enabled;
+ struct goacc_prof_callback_entry *next;
+};
+
+/* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global toggle. */
+static bool goacc_prof_callbacks_enabled[acc_ev_last];
+static struct goacc_prof_callback_entry *goacc_prof_callback_entries[acc_ev_last];
+
+/* This lock is used to protect access to goacc_prof_callbacks_enabled, and
+ goacc_prof_callback_entries. */
+static gomp_mutex_t goacc_prof_lock;
+
+void
+goacc_profiling_initialize (void)
+{
+ gomp_mutex_init (&goacc_prof_lock);
+
+ /* Initially, all callbacks for all events are enabled. */
+ for (int i = 0; i < acc_ev_last; ++i)
+ goacc_prof_callbacks_enabled[i] = true;
+
+ /* We are to invoke an external acc_register_library routine, defaulting to
+ our stub oacc-profiling-acc_register_library.c:acc_register_library
+ implementation. */
+ gomp_debug (0, "%s: calling acc_register_library\n", __FUNCTION__);
+ //TODO.
+ acc_register_library (acc_prof_register, acc_prof_unregister, NULL);
+#ifdef PLUGIN_SUPPORT
+ char *acc_proflibs = getenv ("ACC_PROFLIB");
+ while (acc_proflibs != NULL && acc_proflibs[0] != '\0')
+ {
+ char *acc_proflibs_sep = strchr (acc_proflibs, ';');
+ char *acc_proflib;
+ if (acc_proflibs_sep == acc_proflibs)
+ {
+ /* Stray ";" separator: make sure we don't dlopen the main
+ program. */
+ acc_proflib = NULL;
+ }
+ else
+ {
+ if (acc_proflibs_sep != NULL)
+ {
+ /* Single out the first library. */
+ acc_proflib = gomp_malloc (acc_proflibs_sep - acc_proflibs + 1);
+ memcpy (acc_proflib, acc_proflibs,
+ acc_proflibs_sep - acc_proflibs);
+ acc_proflib[acc_proflibs_sep - acc_proflibs] = '\0';
+ }
+ else
+ {
+ /* No ";" separator, so only one library. */
+ acc_proflib = acc_proflibs;
+ }
+
+ gomp_debug (0, "%s: dlopen(%s)\n", __FUNCTION__, acc_proflib);
+ void *dl_handle = dlopen (acc_proflib, RTLD_LAZY);
+ if (dl_handle != NULL)
+ {
+ typeof (&acc_register_library) a_r_l
+ = dlsym (dl_handle, "acc_register_library");
+ if (a_r_l == NULL)
+ goto dl_fail;
+ /* Avoid duplicate registration, for example if the same shared
+ library is specified in LD_PRELOAD and ACC_PROFLIB -- which
+ TAU 2.26 does when using "tau_exec -openacc". */
+ if (a_r_l != acc_register_library)
+ {
+ gomp_debug (0, " %s: calling %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ //TODO.
+ a_r_l (acc_prof_register, acc_prof_unregister, NULL);
+ }
+ else
+ gomp_debug (0, " %s: skipping duplicate"
+ " %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ }
+ else
+ {
+ dl_fail:
+ gomp_error ("while loading ACC_PROFLIB %s: %s",
+ acc_proflib, dlerror ());
+ if (dl_handle != NULL)
+ {
+ int err = dlclose (dl_handle);
+ dl_handle = NULL;
+ if (err != 0)
+ goto dl_fail;
+ }
+ }
+ }
+
+ if (acc_proflib != acc_proflibs)
+ {
+ free (acc_proflib);
+
+ acc_proflibs = acc_proflibs_sep + 1;
+ }
+ else
+ acc_proflibs = NULL;
+ }
+#endif /* PLUGIN_SUPPORT */
+}
+
+void
+acc_prof_register (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ //TODO
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+ enum
+ {
+ EVENT_KIND_BOGUS,
+ EVENT_KIND_NORMAL,
+ /* As end events invoke callbacks in the reverse order, we register these
+ in the reverse order here. */
+ EVENT_KIND_END,
+ } event_kind = EVENT_KIND_BOGUS;
+ switch (ev)
+ {
+ case acc_ev_none:
+ case acc_ev_device_init_start:
+ case acc_ev_device_shutdown_start:
+ case acc_ev_runtime_shutdown:
+ case acc_ev_create:
+ case acc_ev_delete:
+ case acc_ev_alloc:
+ case acc_ev_free:
+ case acc_ev_enter_data_start:
+ case acc_ev_exit_data_start:
+ case acc_ev_update_start:
+ case acc_ev_compute_construct_start:
+ case acc_ev_enqueue_launch_start:
+ case acc_ev_enqueue_upload_start:
+ case acc_ev_enqueue_download_start:
+ case acc_ev_wait_start:
+ event_kind = EVENT_KIND_NORMAL;
+ break;
+ case acc_ev_device_init_end:
+ case acc_ev_device_shutdown_end:
+ case acc_ev_enter_data_end:
+ case acc_ev_exit_data_end:
+ case acc_ev_update_end:
+ case acc_ev_compute_construct_end:
+ case acc_ev_enqueue_launch_end:
+ case acc_ev_enqueue_upload_end:
+ case acc_ev_enqueue_download_end:
+ case acc_ev_wait_end:
+ event_kind = EVENT_KIND_END;
+ break;
+ case acc_ev_last:
+ break;
+ }
+ if (event_kind == EVENT_KIND_BOGUS)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request for TODOinvalid acc_event_t %d",
+ __FUNCTION__, /* TODO */ (int) ev);
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request with TODOinvalid acc_register_t %d",
+ __FUNCTION__, /* TODO */ (int) reg);
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally enabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global
+ toggle. */
+ goacc_prof_callbacks_enabled[ev] = true;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ /* Silently ignore request. */
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: enabling callbacks\n");
+ goacc_lazy_initialize ();
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = true;
+ return;
+ }
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these?
+ gomp_error ("ignoring %s request for acc_toggle_per_thread with TODO",
+ __FUNCTION__);
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ /* If we already have this callback registered, just increment its ref
+ count. */
+ if (it != NULL)
+ {
+ it->ref++;
+ gomp_debug (0, " already registered;"
+ " incrementing ref count to: %d\n", it->ref);
+ }
+ else
+ {
+ struct goacc_prof_callback_entry *e
+ = gomp_malloc (sizeof (struct goacc_prof_callback_entry));
+ e->cb = cb;
+ e->ref = 1;
+ e->enabled = true;
+ bool prepend = (event_kind == EVENT_KIND_END);
+ /* If we don't have any callback registered yet, also use the
+ "prepend" code path. */
+ if (it_p == NULL)
+ prepend = true;
+ if (prepend)
+ {
+ gomp_debug (0, " prepending\n");
+ e->next = goacc_prof_callback_entries[ev];
+ goacc_prof_callback_entries[ev] = e;
+ }
+ else
+ {
+ gomp_debug (0, " appending\n");
+ e->next = NULL;
+ it_p->next = e;
+ }
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ /* Silently ignore acc_toggle request if not registered. */
+ gomp_debug (0, " not enabling; not registered\n");
+ }
+ else
+ {
+ gomp_debug (0, " enabling\n");
+ it->enabled = true;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+void
+acc_prof_unregister (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ //TODO
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+ if (ev < acc_ev_none
+ || ev >= acc_ev_last)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request for TODOinvalid acc_event_t %d",
+ __FUNCTION__, /* TODO */ (int) ev);
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request with TODOinvalid acc_register_t %d",
+ __FUNCTION__, /* TODO */ (int) reg);
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally disabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global
+ toggle. */
+ goacc_prof_callbacks_enabled[ev] = false;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ /* Silently ignore request. */
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: disabling callbacks\n");
+ goacc_lazy_initialize ();
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = false;
+ return;
+ }
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these?
+ gomp_error ("ignoring %s request for acc_toggle_per_thread with TODO",
+ __FUNCTION__);
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ if (it == NULL)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these?
+ gomp_error ("ignoring %s request for acc_event_t %d: not registered",
+ __FUNCTION__, /* TODO */ (int) ev);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ it->ref--;
+ gomp_debug (0, " decrementing ref count to: %d\n", it->ref);
+ if (it->ref == 0)
+ {
+ if (it_p == NULL)
+ goacc_prof_callback_entries[ev] = it->next;
+ else
+ it_p->next = it->next;
+ free (it);
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ /* Silently ignore acc_toggle request if not registered. */
+ gomp_debug (0, " not disabling; not registered\n");
+ }
+ else
+ {
+ gomp_debug (0, " disabling\n");
+ it->enabled = false;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+/* Set up to dispatch events? */
+
+bool
+goacc_profiling_setup_p (struct goacc_thread *thr,
+ acc_prof_info *prof_info, acc_api_info *api_info)
+{
+ //TODO
+ gomp_debug (0, "%s (%p)\n", __FUNCTION__, thr);
+
+ /* If we don't have any per-thread state yet, we can't register prof_info and
+ api_info. */
+ /* TODO: In this case, should we actually call goacc_lazy_initialize here,
+ and return the "thr" from goacc_profiling_setup_p? */
+ if (__builtin_expect (thr == NULL, false))
+ {
+ //TODO
+ gomp_debug (0, "Can't generate OpenACC Profiling Interface events for"
+ " the current call, construct, or directive\n");
+ return false;
+ }
+
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (false), false);
+ if (thr->prof_info != NULL)
+ {
+ assert (profiling_dispatch_p); //TODO
+ /* Profiling has already been set up for an outer construct. In this
+ case, we continue to use the existing information, and thus return
+ "false" here.
+
+ This can happen, for example, for an enter data directive, which sets
+ up profiling, then calls into acc_copyin, which should not again set
+ up profiling, should not overwrite the existing information. */
+ //TODO: Is this all kosher?
+ return false;
+ }
+
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = prof_info;
+
+ prof_info->event_type = -1; /* Must be set later. */
+ prof_info->valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info->version = _ACC_PROF_INFO_VERSION;
+ //TODO
+ if (thr->dev)
+ {
+ prof_info->device_type = acc_device_type (thr->dev->type);
+ prof_info->device_number = thr->dev->target_id;
+ }
+ else
+ {
+ prof_info->device_type = -1;
+ prof_info->device_number = -1;
+ }
+ prof_info->thread_id = -1; //TODO
+ prof_info->async = acc_async_sync; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info->async_queue = prof_info->async;
+ prof_info->src_file = NULL; //TODO
+ prof_info->func_name = NULL; //TODO
+ prof_info->line_no = -1; //TODO
+ prof_info->end_line_no = -1; //TODO
+ prof_info->func_line_no = -1; //TODO
+ prof_info->func_end_line_no = -1; //TODO
+
+ thr->api_info = api_info;
+
+ api_info->device_api = acc_device_api_none; //TODO
+ api_info->valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info->device_type = prof_info->device_type;
+ api_info->vendor = -1; //TODO
+ api_info->device_handle = NULL; //TODO
+ api_info->context_handle = NULL; //TODO
+ api_info->async_handle = NULL; //TODO
+ }
+
+ return profiling_dispatch_p;
+}
+
+/* Prepare to dispatch events? */
+
+bool
+goacc_profiling_dispatch_p (bool check_not_nested_p)
+{
+ //TODO
+ gomp_debug (0, "%s\n", __FUNCTION__);
+
+ struct goacc_thread *thr = goacc_thread ();
+ if (__builtin_expect (thr == NULL, false))
+ {
+ /* If we don't have any per-thread state yet, that means that per-thread
+ callback dispatch has not been explicitly disabled (which only a call
+ to acc_prof_unregister with acc_toggle_per_thread will do, and that
+ would have allocated per-thread state via goacc_lazy_initialize);
+ initially, all callbacks for all events are enabled. */
+ //TODO
+ gomp_debug (0, " %s: don't have any per-thread state yet\n", __FUNCTION__);
+ }
+ else
+ {
+ if (check_not_nested_p)
+ {
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ }
+
+ if (__builtin_expect (!thr->prof_callbacks_enabled, true))
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled for this thread\n", __FUNCTION__);
+ return false;
+ }
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global toggle. */
+ if (__builtin_expect (!goacc_prof_callbacks_enabled[acc_ev_none], true))
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled globally\n", __FUNCTION__);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return false;
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+
+ return true;
+}
+
+/* Dispatch events.
+
+ TODO.
+ This must only be called if goacc_profiling_dispatch_p returned a true
+ result. */
+
+void
+goacc_profiling_dispatch (acc_prof_info *prof_info, acc_event_info *event_info,
+ acc_api_info *apt_info)
+{
+ acc_event_t event_type = event_info->event_type;
+ //TODO
+ gomp_debug (0, "%s: event_type=%d\n", __FUNCTION__, (int) event_type);
+ //TODO
+ assert (event_type > acc_ev_none
+ && event_type < acc_ev_last);
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ if (!goacc_prof_callbacks_enabled[event_type])
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled for this event type\n", __FUNCTION__);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+
+ for (struct goacc_prof_callback_entry *e
+ = goacc_prof_callback_entries[event_type];
+ e != NULL;
+ e = e->next)
+ {
+ if (!e->enabled)
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled for callback %p\n",
+ __FUNCTION__, e->cb);
+ continue;
+ }
+
+ //TODO
+ gomp_debug (0, " %s: calling callback %p\n", __FUNCTION__, e->cb);
+ e->cb (prof_info, event_info, apt_info);
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
diff --git a/libgomp/plugin/plugin-nvptx.c b/libgomp/plugin/plugin-nvptx.c
index cb18e87..1b6f2d4 100644
--- a/libgomp/plugin/plugin-nvptx.c
+++ b/libgomp/plugin/plugin-nvptx.c
@@ -37,6 +37,7 @@
#include "libgomp-plugin.h"
#include "oacc-plugin.h"
#include "gomp-constants.h"
+#include "oacc-int.h"
#include <pthread.h>
#include <cuda.h>
@@ -903,11 +904,54 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
// num_gangs nctaid.x
// num_workers ntid.y
// vector length ntid.x
+
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info enqueue_launch_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_start;
+
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ enqueue_launch_event_info.launch_event.valid_bytes
+ = _ACC_LAUNCH_EVENT_INFO_VALID_BYTES;
+ enqueue_launch_event_info.launch_event.parent_construct
+ /* TODO = compute_construct_event_info.other_event.parent_construct */
+ = acc_construct_parallel; //TODO: kernels...
+ enqueue_launch_event_info.launch_event.implicit = 1;
+ enqueue_launch_event_info.launch_event.tool_info = NULL;
+ enqueue_launch_event_info.launch_event.kernel_name
+ = /* TODO */ (char *) /* TODO */ targ_fn->launch->fn;
+ enqueue_launch_event_info.launch_event.num_gangs
+ = dims[GOMP_DIM_GANG];
+ enqueue_launch_event_info.launch_event.num_workers
+ = dims[GOMP_DIM_WORKER];
+ enqueue_launch_event_info.launch_event.vector_length
+ = dims[GOMP_DIM_VECTOR];
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
+
CUDA_CALL_ASSERT (cuLaunchKernel, function,
dims[GOMP_DIM_GANG], 1, 1,
dims[GOMP_DIM_VECTOR], dims[GOMP_DIM_WORKER], 1,
0, stream, kargs, 0);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_end;
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
+
GOMP_PLUGIN_debug (0, " %s: kernel %s: finished\n", __FUNCTION__,
targ_fn->launch->fn);
}
@@ -920,6 +964,36 @@ nvptx_alloc (size_t s)
CUdeviceptr d;
CUDA_CALL_ERET (NULL, cuMemAlloc, &d, s);
+
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ bool profiling_dispatch_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_alloc;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ data_event_info.data_event.implicit = 1; //TODO
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = s;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = (void *) d;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
return (void *) d;
}
@@ -950,6 +1024,36 @@ nvptx_free (void *p, struct ptx_device *ptx_dev)
}
CUDA_CALL (cuMemFree, (CUdeviceptr) p);
+
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ bool profiling_dispatch_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_free;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ data_event_info.data_event.implicit = 1; //TODO
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = ps;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = p;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
return true;
}
@@ -1355,10 +1459,47 @@ openacc_exec_internal (void (*fn) (void *), int params, size_t mapnum,
/* Copy the (device) pointers to arguments to the device (dp and hp might in
fact have the same value on a unified-memory system). */
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ /* Always implicit for "data mapping arguments for cuLaunchKernel". */
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = mapnum * sizeof (void *);
+ data_event_info.data_event.host_ptr = hp;
+ if (!params)
+ data_event_info.data_event.device_ptr = (void *) dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
if (!params && mapnum > 0)
CUDA_CALL_ASSERT (cuMemcpyHtoD, dp, (void *) hp,
mapnum * sizeof (void *));
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
if (params)
nvptx_exec (fn, mapnum, hostaddrs, devaddrs, dims, targ_mem_desc,
hp, NULL);
@@ -1439,6 +1580,35 @@ openacc_async_exec_internal (void (*fn) (void *), int params, size_t mapnum,
/* Copy the (device) pointers to arguments to the device (dp and hp might in
fact have the same value on a unified-memory system). */
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ /* Always implicit for "data mapping arguments for cuLaunchKernel". */
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = mapnum * sizeof (void *);
+ data_event_info.data_event.host_ptr = hp;
+ if (!params)
+ data_event_info.data_event.device_ptr = (void *) dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
if (!params && mapnum > 0)
{
CUDA_CALL_ASSERT (cuMemcpyHtoDAsync, dp, (void *) hp,
@@ -1450,6 +1620,14 @@ openacc_async_exec_internal (void (*fn) (void *), int params, size_t mapnum,
block[1] = (void *) nvthd->ptx_dev;
}
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
if (params)
nvptx_exec (fn, mapnum, hostaddrs, devaddrs, dims, targ_mem_desc,
hp, aq->cuda_stream);
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
new file mode 100644
index 0000000..4c1f2bb
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
@@ -0,0 +1,344 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+void cb_compute_construct_start_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 10
+ || state == 30
+ || state == 41
+ || state == 51
+ || state == 91
+ || state == 101
+ || state == 151);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_start_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 11
+ || state == 40
+ || state == 50
+ || state == 90
+ || state == 100
+ || state == 150);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 14
+ || state == 21
+ || state == 32
+ || state == 42
+ || state == 80
+ || state == 103
+ || state == 152);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 13
+ || state == 43
+ || state == 102
+ || state == 154);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_3 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 12
+ || state == 20
+ || state == 31
+ || state == 44
+ || state == 81
+ || state == 104
+ || state == 153);
+ STATE_OP (state, ++);
+}
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 2);
+ }
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 12);
+ }
+ assert (state == 15);
+
+ STATE_OP (state, = 20);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 20);
+ }
+ assert (state == 20);
+
+ STATE_OP (state, = 30);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 31);
+ }
+ assert (state == 33);
+
+ STATE_OP (state, = 40);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 42);
+ }
+ assert (state == 45);
+
+ STATE_OP (state, = 50);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 52);
+ }
+ assert (state == 52);
+
+ STATE_OP (state, = 60);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 60);
+ }
+ assert (state == 60);
+
+ STATE_OP (state, = 70);
+ unreg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 70);
+ }
+ assert (state == 70);
+
+ STATE_OP (state, = 80);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 80);
+ }
+ assert (state == 82);
+
+ STATE_OP (state, = 90);
+ reg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 92);
+ }
+ assert (state == 92);
+
+ STATE_OP (state, = 100);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 102);
+ }
+ assert (state == 105);
+
+ STATE_OP (state, = 110);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 110);
+ }
+ assert (state == 110);
+
+ STATE_OP (state, = 120);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 120);
+ }
+ assert (state == 120);
+
+ STATE_OP (state, = 130);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 130);
+ }
+ assert (state == 130);
+
+ STATE_OP (state, = 140);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 140);
+ }
+ assert (state == 140);
+
+ STATE_OP (state, = 150);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 152);
+ }
+ assert (state == 155);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
new file mode 100644
index 0000000..436f436
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
@@ -0,0 +1,306 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 1)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 2)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 10
+ || state == 110);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 11
+ || state == 111);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ assert (state == 0);
+
+ acc_init (acc_device_host);
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = 12;
+
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 11);
+ }
+ assert (state == 12);
+
+ STATE_OP (state, = 90);
+ acc_shutdown (acc_device_host);
+ assert (state == 90);
+
+
+ STATE_OP (state, = 100);
+ acc_init (acc_device_default);
+ assert (state == 102);
+
+ STATE_OP (state, = 110);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = 12;
+
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 111);
+ }
+ assert (state == 112);
+
+ STATE_OP (state, = 190);
+ acc_shutdown (acc_device_default);
+ assert (state == 190);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
new file mode 100644
index 0000000..1a5b5fb
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
@@ -0,0 +1,253 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+/* See the "DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT" reference in
+ libgomp.texi. */
+#define DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT 0
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int num_gangs, num_workers, vector_length;
+static int async;
+
+void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 0);
+ STATE_OP (state, = 1);
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == NULL);
+ assert (event_info->launch_event.kernel_name != NULL);
+ {
+ char *s = strstr (event_info->launch_event.kernel_name, "main");
+ assert (s != NULL);
+ s = strstr (s, "omp_fn");
+ assert (s != NULL);
+ }
+ if (num_gangs < 1)
+ assert (event_info->launch_event.num_gangs >= 1);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.num_gangs == num_gangs);
+#else
+ /* No parallelized OpenACC kernels constructs, and unparallelized OpenACC
+ kernels constructs must get launched as 1 x 1 x 1 kernels. */
+ assert (event_info->launch_event.num_gangs == 1);
+#endif
+ }
+ if (num_workers < 1)
+ assert (event_info->launch_event.num_workers >= 1);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.num_workers == num_workers);
+#else
+ /* See num_gangs above. */
+ assert (event_info->launch_event.num_workers == 1);
+#endif
+ }
+ if (vector_length < 1)
+ assert (event_info->launch_event.vector_length >= 1);
+ else if (acc_device_type == acc_device_nvidia) /* ... is special. */
+ assert (event_info->launch_event.vector_length == 32);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.vector_length == vector_length);
+#else
+ /* See num_gangs above. */
+ assert (event_info->launch_event.vector_length == 1);
+#endif
+ }
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+}
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
+ assert (state == 0);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ assert (state == 0);
+
+ STATE_OP (state, = 0);
+ /* Implicit async. */
+ async = acc_async_noval;
+ /* Parallelism dimensions: compiler/runtime decides. */
+ num_gangs = num_workers = vector_length = 0;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No acc_ev_enqueue_launch_start. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ STATE_OP (state, = 0);
+ /* Explicit async: without argument. */
+ async = acc_async_noval;
+ /* Parallelism dimensions: literal. */
+ num_gangs = 30;
+ num_workers = 3;
+ vector_length = 5;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels \
+ async \
+ num_gangs (30) num_workers (3) vector_length (5)
+ /* { dg-prune-output "using vector_length \\(32\\), ignoring 5" } */
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No acc_ev_enqueue_launch_start. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ STATE_OP (state, = 0);
+ /* Explicit async: variable. */
+ async = 123;
+ /* Parallelism dimensions: variable. */
+ num_gangs = 22;
+ num_workers = 5;
+ vector_length = 7;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels \
+ async (async) \
+ num_gangs (num_gangs) num_workers (num_workers) vector_length (vector_length)
+ /* { dg-prune-output "using vector_length \\(32\\), ignoring runtime setting" } */
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No acc_ev_enqueue_launch_start. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
new file mode 100644
index 0000000..ef37ae9
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
@@ -0,0 +1,698 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+/* See the "DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT" reference in
+ libgomp.texi. */
+#define DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT 0
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+#else
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+#else
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+#endif
+}
+
+void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 2
+ || state == 102);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_device_init_start);
+#else
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (event_info->other_event.tool_info == tool_info->nested);
+#else
+ assert (event_info->other_event.tool_info == tool_info);
+#endif
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+#else
+ free (tool_info);
+ tool_info = NULL;
+#endif
+}
+
+void cb_enter_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 3
+ || state == 103);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enter_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_enter_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 4
+ || state == 104);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_enter_data_start);
+
+ assert (prof_info->event_type == acc_ev_enter_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+void cb_exit_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 7);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_exit_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_exit_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 8);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_exit_data_start);
+
+ assert (prof_info->event_type == acc_ev_exit_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 0
+ || state == 100);
+ if (state == 100)
+ {
+ /* Compensate for the missing acc_ev_device_init_start and
+ acc_ev_device_init_end. */
+ state += 2;
+ }
+#else
+ if (state == 100)
+ {
+ /* Compensate for the missing acc_ev_device_init_start and
+ acc_ev_device_init_end. */
+ state += 2;
+ }
+ assert (state == 2
+ || state == 102);
+#endif
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing acc_ev_enter_data_start. */
+ state += 1;
+ }
+}
+
+void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing acc_ev_enter_data_end. */
+ state += 1;
+ /* Compensate for the missing acc_ev_enqueue_launch_start and
+ acc_ev_enqueue_launch_end. */
+ state += 2;
+ /* Compensate for the missing acc_ev_exit_data_start and
+ acc_ev_exit_data_end. */
+ state += 2;
+ }
+ else if (acc_async != acc_async_sync)
+ {
+ /* Compensate for the missing acc_ev_exit_data_start and
+ acc_ev_exit_data_end. */
+ state += 2;
+ }
+ assert (state == 9
+ || state == 109);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 5
+ || state == 105);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == NULL);
+ assert (event_info->launch_event.kernel_name != NULL);
+ {
+ char *s = strstr (event_info->launch_event.kernel_name, "main");
+ assert (s != NULL);
+ s = strstr (s, "omp_fn");
+ assert (s != NULL);
+ }
+ assert (event_info->launch_event.num_gangs >= 1);
+ assert (event_info->launch_event.num_workers >= 1);
+ assert (event_info->launch_event.vector_length >= 1);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.launch_event.event_type = event_info->launch_event.event_type;
+ tool_info->nested->event_info.launch_event.kernel_name = strdup (event_info->launch_event.kernel_name);
+ tool_info->nested->event_info.launch_event.num_gangs = event_info->launch_event.num_gangs;
+ tool_info->nested->event_info.launch_event.num_workers = event_info->launch_event.num_workers;
+ tool_info->nested->event_info.launch_event.vector_length = event_info->launch_event.vector_length;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_enqueue_launch_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 6
+ || state == 106);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.launch_event.event_type == acc_ev_enqueue_launch_start);
+ assert (tool_info->nested->event_info.launch_event.kernel_name != NULL);
+ assert (tool_info->nested->event_info.launch_event.num_gangs >= 1);
+ assert (tool_info->nested->event_info.launch_event.num_workers >= 1);
+ assert (tool_info->nested->event_info.launch_event.vector_length >= 1);
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == tool_info->nested);
+ assert (event_info->launch_event.kernel_name != NULL);
+ assert (strcmp (event_info->launch_event.kernel_name, tool_info->nested->event_info.launch_event.kernel_name) == 0);
+ assert (event_info->launch_event.num_gangs == tool_info->nested->event_info.launch_event.num_gangs);
+ assert (event_info->launch_event.num_workers == tool_info->nested->event_info.launch_event.num_workers);
+ assert (event_info->launch_event.vector_length == tool_info->nested->event_info.launch_event.vector_length);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested->event_info.launch_event.kernel_name);
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_enter_data_start, cb_enter_data_start, acc_reg);
+ reg (acc_ev_enter_data_end, cb_enter_data_end, acc_reg);
+ reg (acc_ev_exit_data_start, cb_exit_data_start, acc_reg);
+ reg (acc_ev_exit_data_end, cb_exit_data_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
+ reg (acc_ev_enqueue_launch_end, cb_enqueue_launch_end, acc_reg);
+ assert (state == 0);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = acc_async_sync;
+ assert (state == 0);
+
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 4);
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ assert (state == 10);
+
+ STATE_OP (state, = 100);
+
+ acc_async = 12;
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 104);
+ }
+ assert (state == 110);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
new file mode 100644
index 0000000..a952c7a
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
@@ -0,0 +1,172 @@
+/* Test the "valid_bytes" magic. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+void cb_data_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->data_event.valid_bytes == _ACC_DATA_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+void cb_launch_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+void cb_other_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_other_event, acc_reg);
+ reg_ (acc_ev_create, cb_data_event, acc_reg);
+ reg_ (acc_ev_delete, cb_data_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_data_event, acc_reg);
+ reg_ (acc_ev_free, cb_data_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_other_event, acc_reg);
+}
+
+/* Basic struct. */
+typedef struct A
+{
+ int a;
+ int b;
+#define VALID_BYTES_A \
+ _ACC_PROF_VALID_BYTES_STRUCT (A, b, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (int))
+} A;
+
+/* Add a "char" field. */
+typedef struct B
+{
+ int a;
+ int b;
+ char c;
+#define VALID_BYTES_B \
+ _ACC_PROF_VALID_BYTES_STRUCT (B, c, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} B;
+
+/* Add another "char" field. */
+typedef struct C
+{
+ int a;
+ int b;
+ char c, d;
+#define VALID_BYTES_C \
+ _ACC_PROF_VALID_BYTES_STRUCT (C, d, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} C;
+
+/* Add two "void *" fields. */
+typedef struct D
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+#define VALID_BYTES_D \
+ _ACC_PROF_VALID_BYTES_STRUCT (D, f, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} D;
+
+/* Add another three "char" fields. */
+typedef struct E
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+ char g, h, i;
+#define VALID_BYTES_E \
+ _ACC_PROF_VALID_BYTES_STRUCT (E, i, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} E;
+
+int main()
+{
+ A A1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof A1, VALID_BYTES_A);
+ assert (VALID_BYTES_A <= sizeof A1);
+ DEBUG_printf ("&A1=%p, &A1.b=%p\n", &A1, &A1.b);
+ assert (((char *) &A1) + VALID_BYTES_A == (char *) (&A1.b + 1));
+
+ B B1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof B1, VALID_BYTES_B);
+ assert (VALID_BYTES_B <= sizeof B1);
+ DEBUG_printf ("&B1=%p, &B1.c=%p\n", &B1, &B1.c);
+ assert (((char *) &B1) + VALID_BYTES_B == (char *) (&B1.c + 1));
+
+ assert (VALID_BYTES_B == VALID_BYTES_A + 1 * sizeof (char));
+
+ C C1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof C1, VALID_BYTES_C);
+ assert (VALID_BYTES_C <= sizeof C1);
+ DEBUG_printf ("&C1=%p, &C1.d=%p\n", &C1, &C1.d);
+ assert (((char *) &C1) + VALID_BYTES_C == (char *) (&C1.d + 1));
+
+ assert (VALID_BYTES_C == VALID_BYTES_B + 1 * sizeof (char));
+
+ D D1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof D1, VALID_BYTES_D);
+ assert (VALID_BYTES_D <= sizeof D1);
+ DEBUG_printf ("&D1=%p, &D1.f=%p\n", &D1, &D1.f);
+ assert (((char *) &D1) + VALID_BYTES_D == (char *) (&D1.f + 1));
+
+ assert (VALID_BYTES_D > VALID_BYTES_C);
+
+ E E1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof E1, VALID_BYTES_E);
+ assert (VALID_BYTES_E <= sizeof E1);
+ DEBUG_printf ("&E1=%p, &E1.i=%p\n", &E1, &E1.i);
+ assert (((char *) &E1) + VALID_BYTES_E == (char *) (&E1.i + 1));
+
+ assert (VALID_BYTES_E == VALID_BYTES_D + 3 * sizeof (char));
+
+#pragma acc parallel
+ {
+ }
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
new file mode 100644
index 0000000..11e3ad7
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
@@ -0,0 +1,55 @@
+/* Test "acc_prof_info"'s "version" field. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+void cb_any_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->version == 201711);
+}
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_any_event, acc_reg);
+ reg_ (acc_ev_create, cb_any_event, acc_reg);
+ reg_ (acc_ev_delete, cb_any_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_any_event, acc_reg);
+ reg_ (acc_ev_free, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_any_event, acc_reg);
+}
+
+int main()
+{
+#pragma acc parallel
+ {
+ }
+
+ return 0;
+}
--
2.8.1
^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH, og9] Port OpenACC profiling interface to OG9
@ 2019-06-17 13:28 ` Kwok Cheung Yeung
2019-06-17 17:24 ` Thomas Schwinge
0 siblings, 1 reply; 23+ messages in thread
From: Kwok Cheung Yeung @ 2019-06-17 13:28 UTC (permalink / raw)
To: Thomas Schwinge, gcc-patches; +Cc: Catherine Moore
[-- Attachment #1: Type: text/plain, Size: 431 bytes --]
Hello
This is a straightforward port of the OpenACC profiling interface from
OG8 to OG9, with a few tweaks to compensate for patches that have not
been carried over to OG9. I have also bundled in the profiling hooks and
documentation updates that have been added since the original patch in OG8.
This has been tested on x86_64 with no regressions on the libgomp testsuite.
Okay to push to openacc-gcc-9-branch?
Thanks
Kwok
[-- Attachment #2: 0001-OpenACC-2.6-Profiling-Interface.patch --]
[-- Type: text/plain, Size: 184046 bytes --]
From 8af550dcfc6c339e19293d59692cb595a2cb2d69 Mon Sep 17 00:00:00 2001
From: Thomas Schwinge <thomas@codesourcery.com>
Date: Tue, 28 Feb 2017 17:36:03 +0000
Subject: [PATCH] OpenACC 2.6 Profiling Interface
libgomp/
* acc_prof.h: New file.
* oacc-profiling-acc_register_library.c: Likewise.
* oacc-profiling.c: Likewise.
* Makefile.am (nodist_libsubinclude_HEADERS, libgomp_la_SOURCES):
Add these, respectively.
* Makefile.in: Regenerate.
* libgomp/config/nvptx/oacc-profiling-acc_register_library.c:
New empty file.
* libgomp/config/nvptx/oacc-profiling.c: Likewise.
* env.c (initialize_env): Call goacc_profiling_initialize.
* libgomp-plugin.c: New function
GOMP_PLUGIN_goacc_profiling_dispatch.
* libgomp-plugin.h: Declare function
GOMP_PLUGIN_goacc_profiling_dispatch.
* oacc-plugin.c: New function GOMP_PLUGIN_goacc_thread.
* oacc-plugin.h: Declare function GOMP_PLUGIN_goacc_thread.
* libgomp.map (OACC_2.5): Add acc_prof_lookup, acc_prof_register,
acc_prof_unregister, and acc_register_library.
Add GOMP_PLUGIN_goacc_profiling_dispatch, and
GOMP_PLUGIN_goacc_thread with new GOMP_PLUGIN_1.3 symbol version.
* oacc-int.h (struct goacc_thread): Add "acc_prof_info
*prof_info", "acc_api_info *api_info", and "bool
prof_callbacks_enabled" members.
Declare functions goacc_profiling_initialize,
goacc_profiling_dispatch_p, and goacc_profiling_dispatch.
* oacc-init.c (acc_init_1): Add "acc_construct_t", and "int"
formal parameters. Adjust all users.
(goacc_lazy_initialize): Don't call acc_init; copy code here,
instead.
(acc_init_1, goacc_attach_host_thread_to_device, acc_init)
(goacc_lazy_initialize): Update for OpenACC Profiling Interface.
* oacc-parallel.c (GOACC_parallel_keyed): Likewise.
* plugin/plugin-nvptx.c (cuda_map_create, cuda_map_destroy)
(map_init, map_fini, map_pop, map_push): Add "struct goacc_thread
*" formal parameter. Adjust all users.
(select_stream_for_async, event_gc, nvptx_exec, nvptx_host2dev)
(nvptx_dev2host, nvptx_set_cuda_stream): Call
GOMP_PLUGIN_goacc_thread instead of nvptx_thread.
(cuda_map_create, cuda_map_destroy, nvptx_exec, nvptx_alloc)
(nvptx_free, nvptx_host2dev, nvptx_dev2host): Update for OpenACC
Profiling Interface.
* libgomp.texi: New chapter "OpenACC Profiling Interface".
* testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c: New
file.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c: Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c:
Likewise.
libgomp/
* oacc-async.c (acc_async_test, acc_async_test_all, acc_wait)
(acc_wait_async, acc_wait_all, acc_wait_all_async): Set up
profiling.
* oacc-cuda.c (acc_get_current_cuda_device)
(acc_get_current_cuda_context, acc_get_cuda_stream)
(acc_set_cuda_stream): Likewise.
* oacc-init.c (acc_set_device_type, acc_get_device_type)
(acc_get_device_num): Likewise.
* oacc-mem.c (acc_malloc, acc_free, memcpy_tofrom_device)
(acc_map_data, acc_unmap_data, present_create_copy)
(delete_copyout, update_dev_host): Likewise.
* oacc-parallel.c (GOACC_data_start, GOACC_data_end)
(GOACC_enter_exit_data, GOACC_update, GOACC_wait): Likewise.
* oacc-profiling.c (goacc_profiling_setup_p): New function.
(goacc_profiling_dispatch_p): Add a "bool" formal parameter.
Adjust all users.
* oacc-int.h (goacc_profiling_setup_p)
(goacc_profiling_dispatch_p): Update.
* plugin/plugin-nvptx.c (nvptx_exec, nvptx_wait, nvptx_wait_all):
Generate more profiling events.
* libgomp.texi (OpenACC Environment Variables): Mention
"ACC_PROFLIB".
(OpenACC Profiling Interface): Update.
libgomp/
* oacc-init.c (get_property_any): Add profiling code.
libgomp/
* acc_prof.h (_ACC_PROF_INFO_VERSION): Update to 201711.
* libgomp.texi: Update mentions of OpenACC version to 2.6.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
(cb_any_event): Update expected profiling info version to 201711.
---
libgomp/ChangeLog.openacc | 96 +++
libgomp/Makefile.am | 3 +-
libgomp/Makefile.in | 14 +-
libgomp/acc_prof.h | 237 +++++++
.../nvptx/oacc-profiling-acc_register_library.c | 0
libgomp/config/nvptx/oacc-profiling.c | 0
libgomp/env.c | 2 +
libgomp/libgomp-plugin.c | 9 +
libgomp/libgomp-plugin.h | 6 +
libgomp/libgomp.map | 11 +
libgomp/libgomp.texi | 308 +++++++++
libgomp/oacc-async.c | 114 +++-
libgomp/oacc-cuda.c | 87 ++-
libgomp/oacc-init.c | 203 +++++-
libgomp/oacc-int.h | 14 +
libgomp/oacc-mem.c | 154 ++++-
libgomp/oacc-parallel.c | 475 +++++++++++++-
libgomp/oacc-plugin.c | 13 +
libgomp/oacc-plugin.h | 3 +
libgomp/oacc-profiling-acc_register_library.c | 39 ++
libgomp/oacc-profiling.c | 666 ++++++++++++++++++++
libgomp/plugin/plugin-nvptx.c | 178 ++++++
.../acc_prof-dispatch-1.c | 344 ++++++++++
.../libgomp.oacc-c-c++-common/acc_prof-init-1.c | 306 +++++++++
.../libgomp.oacc-c-c++-common/acc_prof-kernels-1.c | 253 ++++++++
.../acc_prof-parallel-1.c | 698 +++++++++++++++++++++
.../acc_prof-valid_bytes-1.c | 172 +++++
.../libgomp.oacc-c-c++-common/acc_prof-version-1.c | 55 ++
28 files changed, 4399 insertions(+), 61 deletions(-)
create mode 100644 libgomp/acc_prof.h
create mode 100644 libgomp/config/nvptx/oacc-profiling-acc_register_library.c
create mode 100644 libgomp/config/nvptx/oacc-profiling.c
create mode 100644 libgomp/oacc-profiling-acc_register_library.c
create mode 100644 libgomp/oacc-profiling.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
diff --git a/libgomp/ChangeLog.openacc b/libgomp/ChangeLog.openacc
index b3bcb31..bcca494 100644
--- a/libgomp/ChangeLog.openacc
+++ b/libgomp/ChangeLog.openacc
@@ -1,3 +1,99 @@
+2019-01-09 Julian Brown <julian@codesourcery.com>
+
+ * acc_prof.h (_ACC_PROF_INFO_VERSION): Update to 201711.
+ * libgomp.texi: Update mentions of OpenACC version to 2.6.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
+ (cb_any_event): Update expected profiling info version to 201711.
+
+2018-12-20 Maciej W. Rozycki <macro@codesourcery.com>
+
+ * oacc-init.c (get_property_any): Add profiling code.
+
+2017-05-15 Thomas Schwinge <thomas@codesourcery.com>
+
+ * oacc-async.c (acc_async_test, acc_async_test_all, acc_wait)
+ (acc_wait_async, acc_wait_all, acc_wait_all_async): Set up
+ profiling.
+ * oacc-cuda.c (acc_get_current_cuda_device)
+ (acc_get_current_cuda_context, acc_get_cuda_stream)
+ (acc_set_cuda_stream): Likewise.
+ * oacc-init.c (acc_set_device_type, acc_get_device_type)
+ (acc_get_device_num): Likewise.
+ * oacc-mem.c (acc_malloc, acc_free, memcpy_tofrom_device)
+ (acc_map_data, acc_unmap_data, present_create_copy)
+ (delete_copyout, update_dev_host): Likewise.
+ * oacc-parallel.c (GOACC_data_start, GOACC_data_end)
+ (GOACC_enter_exit_data, GOACC_update, GOACC_wait): Likewise.
+ * oacc-profiling.c (goacc_profiling_setup_p): New function.
+ (goacc_profiling_dispatch_p): Add a "bool" formal parameter.
+ Adjust all users.
+ * oacc-int.h (goacc_profiling_setup_p)
+ (goacc_profiling_dispatch_p): Update.
+ * plugin/plugin-nvptx.c (nvptx_exec, nvptx_wait, nvptx_wait_all):
+ Generate more profiling events.
+ * libgomp.texi (OpenACC Environment Variables): Mention
+ "ACC_PROFLIB".
+ (OpenACC Profiling Interface): Update.
+
+2017-05-14 Thomas Schwinge <thomas@codesourcery.com>
+
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-kernels-1.c: New
+ file.
+
+2017-02-28 Thomas Schwinge <thomas@codesourcery.com>
+
+ * acc_prof.h: New file.
+ * oacc-profiling-acc_register_library.c: Likewise.
+ * oacc-profiling.c: Likewise.
+ * Makefile.am (nodist_libsubinclude_HEADERS, libgomp_la_SOURCES):
+ Add these, respectively.
+ * Makefile.in: Regenerate.
+ * libgomp/config/nvptx/oacc-profiling-acc_register_library.c:
+ New empty file.
+ * libgomp/config/nvptx/oacc-profiling.c: Likewise.
+ * env.c (initialize_env): Call goacc_profiling_initialize.
+ * libgomp-plugin.c: New function
+ GOMP_PLUGIN_goacc_profiling_dispatch.
+ * libgomp-plugin.h: Declare function
+ GOMP_PLUGIN_goacc_profiling_dispatch.
+ * oacc-plugin.c: New function GOMP_PLUGIN_goacc_thread.
+ * oacc-plugin.h: Declare function GOMP_PLUGIN_goacc_thread.
+ * libgomp.map (OACC_2.5): Add acc_prof_lookup, acc_prof_register,
+ acc_prof_unregister, and acc_register_library.
+ Add GOMP_PLUGIN_goacc_profiling_dispatch, and
+ GOMP_PLUGIN_goacc_thread with new GOMP_PLUGIN_1.3 symbol version.
+ * oacc-int.h (struct goacc_thread): Add "acc_prof_info
+ *prof_info", "acc_api_info *api_info", and "bool
+ prof_callbacks_enabled" members.
+ Declare functions goacc_profiling_initialize,
+ goacc_profiling_dispatch_p, and goacc_profiling_dispatch.
+ * oacc-init.c (acc_init_1): Add "acc_construct_t", and "int"
+ formal parameters. Adjust all users.
+ (goacc_lazy_initialize): Don't call acc_init; copy code here,
+ instead.
+ (acc_init_1, goacc_attach_host_thread_to_device, acc_init)
+ (goacc_lazy_initialize): Update for OpenACC Profiling Interface.
+ * oacc-parallel.c (GOACC_parallel_keyed): Likewise.
+ * plugin/plugin-nvptx.c (cuda_map_create, cuda_map_destroy)
+ (map_init, map_fini, map_pop, map_push): Add "struct goacc_thread
+ *" formal parameter. Adjust all users.
+ (select_stream_for_async, event_gc, nvptx_exec, nvptx_host2dev)
+ (nvptx_dev2host, nvptx_set_cuda_stream): Call
+ GOMP_PLUGIN_goacc_thread instead of nvptx_thread.
+ (cuda_map_create, cuda_map_destroy, nvptx_exec, nvptx_alloc)
+ (nvptx_free, nvptx_host2dev, nvptx_dev2host): Update for OpenACC
+ Profiling Interface.
+ * libgomp.texi: New chapter "OpenACC Profiling Interface".
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-dispatch-1.c: New
+ file.
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-init-1.c: Likewise.
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-parallel-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-valid_bytes-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c-common/acc_prof-version-1.c:
+ Likewise.
+
2019-05-28 Julian Brown <julian@codesourcery.com>
* testsuite/libgomp.oacc-fortran/gangprivate-attrib-2.f90: New test.
diff --git a/libgomp/Makefile.am b/libgomp/Makefile.am
index 2db3865..a38b66ef 100644
--- a/libgomp/Makefile.am
+++ b/libgomp/Makefile.am
@@ -72,6 +72,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c error.c \
proc.c sem.c bar.c ptrlock.c time.c fortran.c affinity.c target.c \
splay-tree.c libgomp-plugin.c oacc-parallel.c oacc-host.c oacc-init.c \
oacc-mem.c oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
+ oacc-profiling.c oacc-profiling-acc_register_library.c \
affinity-fmt.c teams.c
include $(top_srcdir)/plugin/Makefrag.am
@@ -81,7 +82,7 @@ libgomp_la_SOURCES += openacc.f90
endif
nodist_noinst_HEADERS = libgomp_f.h
-nodist_libsubinclude_HEADERS = omp.h openacc.h
+nodist_libsubinclude_HEADERS = acc_prof.h omp.h openacc.h
if USE_FORTRAN
nodist_finclude_HEADERS = omp_lib.h omp_lib.f90 omp_lib.mod omp_lib_kinds.mod \
openacc_lib.h openacc.f90 openacc.mod openacc_kinds.mod
diff --git a/libgomp/Makefile.in b/libgomp/Makefile.in
index 820a576..d81e3d8 100644
--- a/libgomp/Makefile.in
+++ b/libgomp/Makefile.in
@@ -16,7 +16,7 @@
# Plugins for offload execution, Makefile.am fragment.
#
-# Copyright (C) 2014-2018 Free Software Foundation, Inc.
+# Copyright (C) 2014-2019 Free Software Foundation, Inc.
#
# Contributed by Mentor Embedded.
#
@@ -215,8 +215,9 @@ am_libgomp_la_OBJECTS = alloc.lo atomic.lo barrier.lo critical.lo \
sem.lo bar.lo ptrlock.lo time.lo fortran.lo affinity.lo \
target.lo splay-tree.lo libgomp-plugin.lo oacc-parallel.lo \
oacc-host.lo oacc-init.lo oacc-mem.lo oacc-async.lo \
- oacc-plugin.lo oacc-cuda.lo priority_queue.lo affinity-fmt.lo \
- teams.lo $(am__objects_1)
+ oacc-plugin.lo oacc-cuda.lo priority_queue.lo \
+ oacc-profiling.lo oacc-profiling-acc_register_library.lo \
+ affinity-fmt.lo teams.lo $(am__objects_1)
libgomp_la_OBJECTS = $(am_libgomp_la_OBJECTS)
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
@@ -524,7 +525,7 @@ search_path = $(addprefix $(top_srcdir)/config/, $(config_path)) $(top_srcdir) \
fincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)$(MULTISUBDIR)/finclude
libsubincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)/include
-libgomp_la_LIBADD = $(LIBFFI)
+@USE_LIBFFI_TRUE@libgomp_la_LIBADD = $(LIBFFI)
AM_CPPFLAGS = $(addprefix -I, $(search_path)) $(LIBFFIINCS)
AM_CFLAGS = $(XCFLAGS)
AM_LDFLAGS = $(XLDFLAGS) $(SECTION_LDFLAGS) $(OPT_LDFLAGS)
@@ -553,6 +554,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c \
affinity.c target.c splay-tree.c libgomp-plugin.c \
oacc-parallel.c oacc-host.c oacc-init.c oacc-mem.c \
oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
+ oacc-profiling.c oacc-profiling-acc_register_library.c \
affinity-fmt.c teams.c $(am__append_3)
# Nvidia PTX OpenACC plugin.
@@ -577,7 +579,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c \
@PLUGIN_HSA_TRUE@libgomp_plugin_hsa_la_LIBADD = libgomp.la $(PLUGIN_HSA_LIBS)
@PLUGIN_HSA_TRUE@libgomp_plugin_hsa_la_LIBTOOLFLAGS = --tag=disable-static
nodist_noinst_HEADERS = libgomp_f.h
-nodist_libsubinclude_HEADERS = omp.h openacc.h
+nodist_libsubinclude_HEADERS = acc_prof.h omp.h openacc.h
@USE_FORTRAN_TRUE@nodist_finclude_HEADERS = omp_lib.h omp_lib.f90 omp_lib.mod omp_lib_kinds.mod \
@USE_FORTRAN_TRUE@ openacc_lib.h openacc.f90 openacc.mod openacc_kinds.mod
@@ -755,6 +757,8 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-mem.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-parallel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-plugin.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-profiling-acc_register_library.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-profiling.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ordered.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/parallel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/priority_queue.Plo@am__quote@
diff --git a/libgomp/acc_prof.h b/libgomp/acc_prof.h
new file mode 100644
index 0000000..fd11d4b
--- /dev/null
+++ b/libgomp/acc_prof.h
@@ -0,0 +1,237 @@
+/* OpenACC Runtime Library: Profiling Interface
+
+ Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+#ifndef _ACC_PROF_H
+#define _ACC_PROF_H 1
+
+/* The OpenACC standard doesn't say so explicitly, but as its Profiling
+ Interface makes use of, for example, <openacc.h>'s acc_device_t, we
+ supposedly are to #include that file here. */
+#include <openacc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.1. Events. */
+
+typedef enum acc_event_t
+{
+ acc_ev_none = 0,
+ acc_ev_device_init_start,
+ acc_ev_device_init_end,
+ acc_ev_device_shutdown_start,
+ acc_ev_device_shutdown_end,
+ acc_ev_runtime_shutdown,
+ acc_ev_create,
+ acc_ev_delete,
+ acc_ev_alloc,
+ acc_ev_free,
+ acc_ev_enter_data_start,
+ acc_ev_enter_data_end,
+ acc_ev_exit_data_start,
+ acc_ev_exit_data_end,
+ acc_ev_update_start,
+ acc_ev_update_end,
+ acc_ev_compute_construct_start,
+ acc_ev_compute_construct_end,
+ acc_ev_enqueue_launch_start,
+ acc_ev_enqueue_launch_end,
+ acc_ev_enqueue_upload_start,
+ acc_ev_enqueue_upload_end,
+ acc_ev_enqueue_download_start,
+ acc_ev_enqueue_download_end,
+ acc_ev_wait_start,
+ acc_ev_wait_end,
+ acc_ev_last
+} acc_event_t;
+
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.2. Callbacks Signature. */
+
+//TODO
+/* 'In all cases, a datatype of "size_t" means a 32-bit integer for a 32-bit
+ binary and a 64-bit integer for a 64-bit binary, and a datatype "int" means
+ a 32-bit integer for both 32-bit and 64-bit binaries'. */
+typedef long int _acc_prof_size_t;
+typedef int _acc_prof_int_t;
+
+/* Internal helpers: a struct's "valid_bytes" may be less than its "sizeof". */
+#define _ACC_PROF_VALID_BYTES_STRUCT(_struct, _lastfield, _valid_bytes_lastfield) \
+ offsetof (_struct, _lastfield) + (_valid_bytes_lastfield)
+#if 0 /* Untested. */
+#define _ACC_PROF_VALID_BYTES_TYPE_N(_type, _n, _valid_bytes_type) \
+ ((_n - 1) * sizeof (_type) + (_valid_bytes_type))
+#endif
+#define _ACC_PROF_VALID_BYTES_BASICTYPE(_basictype) \
+ (sizeof (_basictype))
+
+typedef struct acc_prof_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ _acc_prof_int_t version;
+ acc_device_t device_type;
+ _acc_prof_int_t device_number;
+ _acc_prof_int_t thread_id;
+ _acc_prof_size_t async;
+ _acc_prof_size_t async_queue;
+ char *src_file;
+ char *func_name;
+ _acc_prof_int_t line_no, end_line_no;
+ _acc_prof_int_t func_line_no, func_end_line_no;
+#define _ACC_PROF_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_prof_info, func_end_line_no, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_int_t))
+} acc_prof_info;
+
+/* We implement the OpenACC 2.6 Profiling Interface. */
+#define _ACC_PROF_INFO_VERSION 201711
+
+typedef enum acc_construct_t
+{
+ acc_construct_parallel = 0,
+ acc_construct_kernels,
+ acc_construct_loop,
+ acc_construct_data,
+ acc_construct_enter_data,
+ acc_construct_exit_data,
+ acc_construct_host_data,
+ acc_construct_atomic,
+ acc_construct_declare,
+ acc_construct_init,
+ acc_construct_shutdown,
+ acc_construct_set,
+ acc_construct_update,
+ acc_construct_routine,
+ acc_construct_wait,
+ acc_construct_runtime_api
+} acc_construct_t;
+
+typedef struct acc_data_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ char *var_name;
+ _acc_prof_size_t bytes;
+ void *host_ptr;
+ void *device_ptr;
+#define _ACC_DATA_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_data_event_info, device_ptr, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_data_event_info;
+
+typedef struct acc_launch_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ char *kernel_name;
+ _acc_prof_size_t num_gangs, num_workers, vector_length;
+#define _ACC_LAUNCH_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_launch_event_info, vector_length, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_size_t))
+} acc_launch_event_info;
+
+typedef struct acc_other_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+#define _ACC_OTHER_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_other_event_info, tool_info, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_other_event_info;
+
+typedef union acc_event_info
+{
+ acc_event_t event_type;
+ acc_data_event_info data_event;
+ acc_launch_event_info launch_event;
+ acc_other_event_info other_event;
+} acc_event_info;
+
+//TODO: should these relate to acc_device_t values?
+typedef enum acc_device_api
+{
+ acc_device_api_none = 0,
+ acc_device_api_cuda,
+ acc_device_api_opencl,
+ acc_device_api_coi,
+ acc_device_api_other
+} acc_device_api;
+
+typedef struct acc_api_info
+{
+ acc_device_api device_api;
+ _acc_prof_int_t valid_bytes;
+ acc_device_t device_type;
+ _acc_prof_int_t vendor;
+ void *device_handle;
+ void *context_handle;
+ void *async_handle;
+#define _ACC_API_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_api_info, async_handle, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_api_info;
+
+typedef void (*acc_prof_callback) (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+
+
+/* OpenACC 2.5, 5. Profiling Interface, 5.3. Loading the Library. */
+
+typedef enum acc_register_t
+{
+ acc_reg = 0,
+ acc_toggle = 1,
+ acc_toggle_per_thread = 2
+} acc_register_t;
+
+typedef void (*acc_prof_reg) (acc_event_t, acc_prof_callback, acc_register_t);
+extern void acc_prof_register (acc_event_t, acc_prof_callback, acc_register_t) __GOACC_NOTHROW;
+extern void acc_prof_unregister (acc_event_t, acc_prof_callback, acc_register_t) __GOACC_NOTHROW;
+typedef void (*acc_query_fn) ();
+typedef acc_query_fn (*acc_prof_lookup_func) (const char *);
+extern acc_query_fn acc_prof_lookup (const char *) __GOACC_NOTHROW;
+/* Don't tag "acc_register_library" as "__GOACC_NOTHROW": this function can be
+ overridden by the application, and must be expected to do "everything". */
+extern void acc_register_library (acc_prof_reg, acc_prof_reg, acc_prof_lookup_func);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ACC_PROF_H */
diff --git a/libgomp/config/nvptx/oacc-profiling-acc_register_library.c b/libgomp/config/nvptx/oacc-profiling-acc_register_library.c
new file mode 100644
index 0000000..e69de29
diff --git a/libgomp/config/nvptx/oacc-profiling.c b/libgomp/config/nvptx/oacc-profiling.c
new file mode 100644
index 0000000..e69de29
diff --git a/libgomp/env.c b/libgomp/env.c
index 7937fbb..29d9f58 100644
--- a/libgomp/env.c
+++ b/libgomp/env.c
@@ -1425,5 +1425,7 @@ initialize_env (void)
parse_gomp_openacc_dim ();
goacc_runtime_initialize ();
+
+ goacc_profiling_initialize ();
}
#endif /* LIBGOMP_OFFLOADED_ONLY */
diff --git a/libgomp/libgomp-plugin.c b/libgomp/libgomp-plugin.c
index 5b77a53..f9f77b1 100644
--- a/libgomp/libgomp-plugin.c
+++ b/libgomp/libgomp-plugin.c
@@ -29,6 +29,7 @@
#include <stdlib.h>
#include "libgomp.h"
+#include "oacc-int.h"
#include "libgomp-plugin.h"
void *
@@ -78,3 +79,11 @@ GOMP_PLUGIN_fatal (const char *msg, ...)
gomp_vfatal (msg, ap);
va_end (ap);
}
+
+void
+GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *prof_info,
+ acc_event_info *event_info,
+ acc_api_info *api_info)
+{
+ goacc_profiling_dispatch (prof_info, event_info, api_info);
+}
diff --git a/libgomp/libgomp-plugin.h b/libgomp/libgomp-plugin.h
index da8ce26..81819db 100644
--- a/libgomp/libgomp-plugin.h
+++ b/libgomp/libgomp-plugin.h
@@ -33,6 +33,8 @@
#include <stddef.h>
#include <stdint.h>
+#include "acc_prof.h"
+
#ifdef __cplusplus
extern "C" {
#endif
@@ -95,6 +97,10 @@ extern void GOMP_PLUGIN_error (const char *, ...)
extern void GOMP_PLUGIN_fatal (const char *, ...)
__attribute__ ((noreturn, format (printf, 1, 2)));
+extern void GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *,
+ acc_event_info *,
+ acc_api_info *);
+
/* Prototypes for functions implemented by libgomp plugins. */
extern const char *GOMP_OFFLOAD_get_name (void);
extern unsigned int GOMP_OFFLOAD_get_caps (void);
diff --git a/libgomp/libgomp.map b/libgomp/libgomp.map
index 717ae66..d07f4fe 100644
--- a/libgomp/libgomp.map
+++ b/libgomp/libgomp.map
@@ -466,6 +466,10 @@ OACC_2.5 {
acc_delete_finalize_async_array_h_;
acc_memcpy_from_device_async;
acc_memcpy_to_device_async;
+ acc_prof_lookup;
+ acc_prof_register;
+ acc_prof_unregister;
+ acc_register_library;
acc_update_device_async;
acc_update_device_async_32_h_;
acc_update_device_async_64_h_;
@@ -536,3 +540,10 @@ GOMP_PLUGIN_1.2 {
global:
GOMP_PLUGIN_acc_default_dim;
} GOMP_PLUGIN_1.1;
+
+# TODO
+GOMP_PLUGIN_1.3 {
+ global:
+ GOMP_PLUGIN_goacc_profiling_dispatch;
+ GOMP_PLUGIN_goacc_thread;
+} GOMP_PLUGIN_1.2;
diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi
index 7538846..25c17e0 100644
--- a/libgomp/libgomp.texi
+++ b/libgomp/libgomp.texi
@@ -111,6 +111,7 @@ changed to GNU Offloading and Multi Processing Runtime Library.
asynchronous operations.
* OpenACC Library Interoperability:: OpenACC library interoperability with the
NVIDIA CUBLAS library.
+* OpenACC Profiling Interface::
* The libgomp ABI:: Notes on the external ABI presented by libgomp.
* Reporting Bugs:: How to report bugs in the GNU Offloading and
Multi Processing Runtime Library.
@@ -2874,11 +2875,14 @@ A.2.1.4.
The variables @env{ACC_DEVICE_TYPE} and @env{ACC_DEVICE_NUM}
are defined by section 4 of the OpenACC specification in version 2.6.
+The variable @code{ACC_PROFLIB} is defined by section 4 of the OpenACC
+specification in version 2.6.
The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
@menu
* ACC_DEVICE_TYPE::
* ACC_DEVICE_NUM::
+* ACC_PROFLIB::
* GCC_ACC_NOTIFY::
@end menu
@@ -2904,6 +2908,19 @@ The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
+@node ACC_PROFLIB
+@section @code{ACC_PROFLIB}
+@table @asis
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+4.3.
+@end table
+
+
+
@node GCC_ACC_NOTIFY
@section @code{GCC_ACC_NOTIFY}
@table @asis
@@ -3120,6 +3137,297 @@ Application Programming Interface”, Version 2.6.}
@c ---------------------------------------------------------------------
+@c OpenACC Profiling Interface
+@c ---------------------------------------------------------------------
+
+@node OpenACC Profiling Interface
+@chapter OpenACC Profiling Interface
+
+@section Implementation Status and Implementation-Defined Behavior
+
+We're implementing most of the Profiling Interface as defined by
+the OpenACC 2.6 specification. The specification doesn't
+clearly define some aspects of its Profiling Interface, so we're
+clarifying these as @emph{implementation-defined behavior} here. We
+already have reported to the OpenACC Technical Committee some issues,
+and will report more, later on.
+
+This implementation of the OpenACC Profiling Interface is tuned to
+keep the performance impact as low as possible when it's not in use.
+This is relevant, as the Profiling Interface affects all the
+@emph{hot} code paths (in the target code, not in the offloaded code).
+Users of the OpenACC Profiling Interface can be expected to understand
+that performance will always be impacted to some degree: for example,
+because of the @emph{runtime} (libgomp) calling into a third-party
+@emph{library} for every event that has been registered.
+
+This implementation of the OpenACC Profiling Interface has not yet
+been validated for use in multi-threaded code. This is a more general
+issue; see CSTS-110 @cite{Make sure all OpenACC entry points in
+libgomp are thread-safe}.
+
+The @code{acc_prof_lookup} interface is not implemented, and
+@code{acc_register_library} will receive @code{NULL} for its
+@code{lookup} parameter.
+
+Remarks about data provided to callbacks:
+
+@table @asis
+
+@item @code{acc_prof_info.event_type}
+It is not clear if for @emph{nested} event callbacks (for example,
+@code{acc_ev_enqueue_launch_start} as part of a parent compute
+construct), this should be set for the nested event
+(@code{acc_ev_enqueue_launch_start}), or if the value of the parent
+construct should remain (@code{acc_ev_compute_construct_start}). In
+this implementation, the value will generally correspond to the
+innermost nested event type.
+
+@item @code{acc_prof_info.device_type}
+@itemize
+
+@item
+For @code{acc_ev_compute_construct_start}, and in presence of an
+@code{if} clause with @emph{false} argument, this will still refer to
+the offloading device type; unsure whether that's the expected
+behavior.
+
+@item
+Complementary to the item before, for
+@code{acc_ev_compute_construct_end}, this is set to
+@code{acc_device_host} in presence of an @code{if} clause with
+@emph{false} argument, unsure whether that's the expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.thread_id}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.async}
+@itemize
+
+@item
+Not yet implemented correctly for
+@code{acc_ev_compute_construct_start}.
+
+@item
+In a compute construct, for host-fallback
+execution/@code{acc_device_host} it will always be
+@code{acc_async_sync}; unsure if that is the expected behavior.
+
+@item
+For @code{acc_ev_device_init_start} and @code{acc_ev_device_init_end},
+it will always be @code{acc_async_sync}; unsure if that is the
+expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.async_queue}
+There is no @cite{limited number of asynchronous queues} in libgomp.
+We define this to always have the same value as
+@code{acc_prof_info.async}.
+
+@item @code{acc_prof_info.file}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_prof_info.func_name}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_prof_info.line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_event_info.event_type}, @code{acc_event_info.*.event_type}
+Relating to @code{acc_prof_info.event_type} discussed above, in this
+implementation, this will always be the same value as
+@code{acc_prof_info.event_type}.
+
+@item @code{acc_event_info.*.parent_construct}
+@itemize
+
+@item
+Will be @code{acc_construct_parallel} for OpenACC kernels constructs;
+should be @code{acc_construct_kernels}.
+
+@item
+Will be @code{acc_construct_enter_data} or
+@code{acc_construct_exit_data} when processing variable mappings
+specified in OpenACC declare directives; should be
+@code{acc_construct_declare}.
+
+@item
+For implicit @code{acc_ev_device_init_start},
+@code{acc_ev_device_init_end}, and explicit as well as implicit
+@code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start},
+@code{acc_ev_enqueue_download_end}, @code{acc_ev_wait_start}, and
+@code{acc_ev_wait_end}, will be
+@code{acc_construct_parallel}; should reflect the real parent
+construct.
+
+@end itemize
+
+@item @code{acc_event_info.*.implicit}
+For @code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start},
+@code{acc_ev_enqueue_download_end}, @code{acc_ev_wait_start}, and
+@code{acc_ev_wait_end}, this currently will be @code{1}
+also for explicit usage.
+
+@item @code{acc_event_info.data_event.var_name}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_event_info.data_event.host_ptr}
+For @code{acc_ev_alloc}, and @code{acc_ev_free}, this is always
+@code{NULL}.
+
+@item @code{typedef union acc_api_info}
+@dots{} as printed in @cite{5.2.3. Third Argument: API-Specific
+Information}, should obviously be @code{typedef @emph{struct}
+acc_api_info}.
+
+@item @code{acc_api_info.device_api}
+Possibly not yet implemented correctly for
+@code{acc_ev_compute_construct_start},
+@code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}:
+will always be @code{acc_device_api_none} for these event types.
+For @code{acc_ev_enter_data_start}, it will be
+@code{acc_device_api_none} in some cases.
+
+@item @code{acc_api_info.device_type}
+Always the same as @code{acc_prof_info.device_type}.
+
+@item @code{acc_api_info.vendor}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_api_info.device_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.context_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.async_handle}
+Always @code{NULL}; not yet implemented.
+
+@end table
+
+Remarks about certain event types:
+
+@table @asis
+
+@item @code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}
+@itemize
+
+@item
+@c See DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT in
+@c libgomp.oacc-c-c++-common/acc_prof-parallel-1.c.
+Whan a compute construct triggers implicit
+@code{acc_ev_device_init_start} and @code{acc_ev_device_init_end}
+events, they currently aren't @emph{nested within} the corresponding
+@code{acc_ev_compute_construct_start} and
+@code{acc_ev_compute_construct_end}, but they're currently observed
+@emph{before} @code{acc_ev_compute_construct_start}. It is not clear
+what to do: the standard asks us provide a lot of details to the
+@code{acc_ev_compute_construct_start} callback, without (implicitly)
+initializing a device before?
+
+@item
+Callbacks for these event types will not be invoked for calls to the
+@code{acc_set_device_type} and @code{acc_set_device_num} functions;
+it's not clear if they should be.
+
+@end itemize
+
+@item @code{acc_ev_enter_data_start}, @code{acc_ev_enter_data_end}, @code{acc_ev_exit_data_start}, @code{acc_ev_exit_data_end}
+@itemize
+
+@item
+Callbacks for these event types will also be invoked for OpenACC
+host_data constructs; it's not clear if they should be.
+
+@item
+Callbacks for these event types will also be invoked when processing
+variable mappings specified in OpenACC declare directives; it's not
+clear if they should be.
+
+@end itemize
+
+@end table
+
+Callbacks for the following event types will be invoked, but dispatch
+and information provided therein has not yet been thoroughly reviewed:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@item @code{acc_ev_update_start}, @code{acc_ev_update_end}
+@item @code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end}
+@item @code{acc_ev_enqueue_download_start}, @code{acc_ev_enqueue_download_end}
+@item @code{acc_ev_wait_start}, @code{acc_ev_wait_end}
+@end itemize
+
+During device initialization, and finalization, respectively,
+callbacks for the following event types will not yet be invoked:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@end itemize
+
+Callbacks for the following event types have not yet been implemented,
+so currently won't be invoked:
+
+@itemize
+@item @code{acc_ev_device_shutdown_start}, @code{acc_ev_device_shutdown_end}
+@item @code{acc_ev_runtime_shutdown}
+@item @code{acc_ev_create}, @code{acc_ev_delete}
+@end itemize
+
+For the following runtime library functions, not all expected
+callbacks will be invoked (mostly concerning implicit device
+initialization):
+
+@itemize
+@item @code{acc_get_num_devices}
+@item @code{acc_set_device_type}
+@item @code{acc_get_device_type}
+@item @code{acc_set_device_num}
+@item @code{acc_get_device_num}
+@item @code{acc_init}
+@item @code{acc_shutdown}
+@end itemize
+
+Aside from implicit device initialization, for the following runtime
+library functions, no callbacks will be invoked for shared-memory
+offloading devices (it's not clear if they should be):
+
+@itemize
+@item @code{acc_malloc}
+@item @code{acc_free}
+@item @code{acc_copyin}, @code{acc_present_or_copyin}, @code{acc_copyin_async}
+@item @code{acc_create}, @code{acc_present_or_create}, @code{acc_create_async}
+@item @code{acc_copyout}, @code{acc_copyout_async}
+@item @code{acc_delete}, @code{acc_delete_async}
+@item @code{acc_update_device}, @code{acc_update_device_async}
+@item @code{acc_update_self}, @code{acc_update_self_async}
+@item @code{acc_map_data}, @code{acc_unmap_data}
+@item @code{acc_memcpy_to_device}, @code{acc_memcpy_to_device_async}
+@item @code{acc_memcpy_from_device}, @code{acc_memcpy_from_device_async}
+@end itemize
+
+
+
+@c ---------------------------------------------------------------------
@c The libgomp ABI
@c ---------------------------------------------------------------------
diff --git a/libgomp/oacc-async.c b/libgomp/oacc-async.c
index 51bb676..bf56560 100644
--- a/libgomp/oacc-async.c
+++ b/libgomp/oacc-async.c
@@ -125,7 +125,7 @@ lookup_goacc_asyncqueue (struct goacc_thread *thr, bool create, int async)
ret_aq = dev->openacc.async.asyncqueue[async];
- end:
+end:
gomp_mutex_unlock (&dev->openacc.async.lock);
return ret_aq;
}
@@ -149,11 +149,30 @@ acc_async_test (int async)
if (!thr || !thr->dev)
gomp_fatal ("no device active");
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
- if (!aq)
- return 1;
- else
- return thr->dev->openacc.async.test_func (aq);
+ int res = 1;
+ if (aq)
+ res = thr->dev->openacc.async.test_func (aq);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return res;
}
int
@@ -161,6 +180,12 @@ acc_async_test_all (void)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
int ret = 1;
gomp_mutex_lock (&thr->dev->openacc.async.lock);
for (goacc_aq_list l = thr->dev->openacc.async.active; l; l = l->next)
@@ -170,6 +195,13 @@ acc_async_test_all (void)
break;
}
gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return ret;
}
@@ -178,9 +210,27 @@ acc_wait (int async)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
if (aq && !thr->dev->openacc.async.synchronize_func (aq))
gomp_fatal ("wait on %d failed", async);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
/* acc_async_wait is an OpenACC 1.0 compatibility name for acc_wait. */
@@ -199,16 +249,28 @@ acc_wait_async (int async1, int async2)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async2; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq1 = lookup_goacc_asyncqueue (thr, false, async1);
/* TODO: Is this also correct for acc_async_sync, assuming that in this case,
we'll always be synchronous anyways? */
if (!aq1)
- return;
+ goto end;
goacc_aq aq2 = lookup_goacc_asyncqueue (thr, true, async2);
/* An async queue is always synchronized with itself. */
if (aq1 == aq2)
- return;
+ goto end;
if (aq2)
{
@@ -222,12 +284,26 @@ acc_wait_async (int async1, int async2)
if (!thr->dev->openacc.async.synchronize_func (aq1))
gomp_fatal ("wait on %d failed", async1);
}
+
+end:
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
acc_wait_all (void)
{
struct gomp_device_descr *dev = get_goacc_thread_device ();
+ struct goacc_thread *thr = goacc_thread ();
+
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
bool ret = true;
gomp_mutex_lock (&dev->openacc.async.lock);
@@ -237,6 +313,12 @@ acc_wait_all (void)
if (!ret)
gomp_fatal ("wait all failed");
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
/* acc_async_wait_all is an OpenACC 1.0 compatibility name for acc_wait_all. */
@@ -255,6 +337,18 @@ acc_wait_all_async (int async)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq waiting_queue = lookup_goacc_asyncqueue (thr, true, async);
bool ret = true;
@@ -272,6 +366,12 @@ acc_wait_all_async (int async)
if (!ret)
gomp_fatal ("wait all async(%d) failed", async);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
attribute_hidden void
diff --git a/libgomp/oacc-cuda.c b/libgomp/oacc-cuda.c
index 1ca7149..4ba0bb3 100644
--- a/libgomp/oacc-cuda.c
+++ b/libgomp/oacc-cuda.c
@@ -37,10 +37,23 @@ acc_get_current_cuda_device (void)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_device_func)
- return thr->dev->openacc.cuda.get_current_device_func ();
+ ret = thr->dev->openacc.cuda.get_current_device_func ();
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
- return NULL;
+ return ret;
}
void *
@@ -48,10 +61,23 @@ acc_get_current_cuda_context (void)
{
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_context_func)
- return thr->dev->openacc.cuda.get_current_context_func ();
-
- return NULL;
+ ret = thr->dev->openacc.cuda.get_current_context_func ();
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return ret;
}
void *
@@ -62,14 +88,33 @@ acc_get_cuda_stream (int async)
if (!async_valid_p (async))
return NULL;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_stream_func)
{
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
if (aq)
- return thr->dev->openacc.cuda.get_stream_func (aq);
+ ret = thr->dev->openacc.cuda.get_stream_func (aq);
}
- return NULL;
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return ret;
}
/* As of OpenACC 2.6, the return code of this function appears to be
@@ -87,6 +132,18 @@ acc_set_cuda_stream (int async, void *stream)
thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
int ret = 0;
if (thr && thr->dev && thr->dev->openacc.cuda.set_stream_func)
{
@@ -98,11 +155,19 @@ acc_set_cuda_stream (int async, void *stream)
assert (async == acc_async_sync);
gomp_debug (0, "Refusing request to set CUDA stream associated"
" with \"acc_async_sync\"\n");
- return 0;
}
- gomp_mutex_lock (&thr->dev->openacc.async.lock);
- ret = thr->dev->openacc.cuda.set_stream_func (aq, stream);
- gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+ else
+ {
+ gomp_mutex_lock (&thr->dev->openacc.async.lock);
+ ret = thr->dev->openacc.cuda.set_stream_func (aq, stream);
+ gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+ }
+ }
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
}
return ret;
diff --git a/libgomp/oacc-init.c b/libgomp/oacc-init.c
index 0cd673e..57b3b87 100644
--- a/libgomp/oacc-init.c
+++ b/libgomp/oacc-init.c
@@ -228,8 +228,70 @@ acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)
held before calling this function. */
static struct gomp_device_descr *
-acc_init_1 (acc_device_t d)
+acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
{
+ bool check_not_nested_p;
+ if (implicit)
+ {
+ /* In the implicit case, there should (TODO: must?) already be something
+ have been set up for an outer construct. */
+ check_not_nested_p = false;
+ }
+ else
+ {
+ check_not_nested_p = true;
+ /* TODO: should we set "thr->prof_info" etc. in this case (acc_init)?
+ The problem is, that we don't have "thr" yet? (So,
+ "check_not_nested_p = true" also is pointless actually.) */
+ }
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (check_not_nested_p),
+ false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_device_init_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = d;
+ prof_info.device_number = goacc_device_num;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = acc_async_sync; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info device_init_event_info;
+ if (profiling_dispatch_p)
+ {
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ device_init_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ device_init_event_info.other_event.parent_construct = parent_construct;
+ device_init_event_info.other_event.implicit = implicit;
+ device_init_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ api_info.device_api = acc_device_api_none; //TODO
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info, &api_info);
+
struct gomp_device_descr *base_dev, *acc_dev;
int ndevs;
@@ -261,6 +323,14 @@ acc_init_1 (acc_device_t d)
acc_init_state = initialized;
gomp_mutex_unlock (&acc_init_state_lock);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_device_init_end;
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info,
+ &api_info);
+ }
+
return base_dev;
}
@@ -454,7 +524,11 @@ goacc_attach_host_thread_to_device (int ord)
thr->dev = acc_dev = &base_dev[ord];
thr->saved_bound_dev = NULL;
thr->mapped_data = NULL;
-
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ /* Initially, all callbacks for all events are enabled. */
+ thr->prof_callbacks_enabled = true;
+
thr->target_tls
= acc_dev->openacc.create_thread_data_func (ord);
}
@@ -468,9 +542,7 @@ acc_init (acc_device_t d)
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
-
- cached_base_dev = acc_init_1 (d);
-
+ cached_base_dev = acc_init_1 (d, acc_construct_runtime_api, 0);
gomp_mutex_unlock (&acc_device_lock);
goacc_attach_host_thread_to_device (-1);
@@ -495,11 +567,21 @@ ialias (acc_shutdown)
int
acc_get_num_devices (acc_device_t d)
{
+#if 0 //TODO
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ prof_info.device_type = d; //TODO
+#endif
+
int n = 0;
struct gomp_device_descr *acc_dev;
if (d == acc_device_none)
- return 0;
+ goto out;
gomp_init_targets_once ();
@@ -508,12 +590,21 @@ acc_get_num_devices (acc_device_t d)
gomp_mutex_unlock (&acc_device_lock);
if (!acc_dev)
- return 0;
+ goto out;
n = acc_dev->get_num_devices_func ();
if (n < 0)
n = 0;
+ out:
+#if 0 //TODO
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+#endif
+
return n;
}
@@ -529,6 +620,14 @@ acc_set_device_type (acc_device_t d)
struct gomp_device_descr *base_dev, *acc_dev;
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ prof_info.device_type = d; //TODO
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
@@ -553,6 +652,12 @@ acc_set_device_type (acc_device_t d)
}
goacc_attach_host_thread_to_device (-1);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
ialias (acc_set_device_type)
@@ -588,12 +693,25 @@ acc_get_device_type (void)
;
else
{
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr,
+ &prof_info, &api_info),
+ false);
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (acc_device_default, true);
gomp_mutex_unlock (&acc_device_lock);
res = acc_device_type (dev->type);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
assert (res != acc_device_default
@@ -611,6 +729,14 @@ acc_get_device_num (acc_device_t d)
const struct gomp_device_descr *dev;
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ prof_info.device_type = d; //TODO
+
if (d >= _ACC_device_hwm)
gomp_fatal ("unknown device type %u", (unsigned) d);
@@ -620,6 +746,12 @@ acc_get_device_num (acc_device_t d)
dev = resolve_device (d, true);
gomp_mutex_unlock (&acc_device_lock);
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
if (thr && thr->base_dev == dev && thr->dev)
return thr->dev->target_id;
@@ -631,6 +763,19 @@ ialias (acc_get_device_num)
void
acc_set_device_num (int ord, acc_device_t d)
{
+#if 0 //TODO
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.device_type = d; //TODO
+ prof_info.device_type = ord; //TODO
+ }
+#endif
+
struct gomp_device_descr *base_dev, *acc_dev;
int num_devices;
@@ -668,6 +813,14 @@ acc_set_device_num (int ord, acc_device_t d)
}
goacc_device_num = ord;
+
+#if 0 //TODO
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+#endif
}
ialias (acc_set_device_num)
@@ -688,14 +841,32 @@ get_property_any (int ord, acc_device_t d, acc_device_property_t prop)
if (d == acc_device_current && (!thr || !thr->dev))
return (union gomp_device_property_value) { .val = 0 };
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
if (d == acc_device_current)
{
+ if (profiling_setup_p)
+ {
+ prof_info.device_type = acc_device_type (thr->dev->type);
+ prof_info.device_number = thr->dev->target_id;
+ }
+
dev = thr->dev;
}
else
{
int num_devices;
+ if (profiling_setup_p)
+ {
+ prof_info.device_type = d;
+ prof_info.device_number = ord;
+ }
+
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (d, false);
@@ -719,6 +890,12 @@ get_property_any (int ord, acc_device_t d, acc_device_property_t prop)
propval = dev->get_property_func (dev->target_id, prop);
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return propval;
}
@@ -809,12 +986,16 @@ attribute_hidden void
goacc_lazy_initialize (void)
{
struct goacc_thread *thr = goacc_thread ();
-
if (thr && thr->dev)
return;
+ gomp_init_targets_once ();
+
+ gomp_mutex_lock (&acc_device_lock);
if (!cached_base_dev)
- acc_init (acc_device_default);
- else
- goacc_attach_host_thread_to_device (-1);
+ cached_base_dev = acc_init_1 (acc_device_default,
+ /* TODO */ acc_construct_parallel, 1);
+ gomp_mutex_unlock (&acc_device_lock);
+
+ goacc_attach_host_thread_to_device (-1);
}
diff --git a/libgomp/oacc-int.h b/libgomp/oacc-int.h
index e4b6ea6..980cf32 100644
--- a/libgomp/oacc-int.h
+++ b/libgomp/oacc-int.h
@@ -40,6 +40,7 @@
#include "openacc.h"
#include "config.h"
+#include "acc_prof.h"
#include <stddef.h>
#include <stdbool.h>
#include <stdarg.h>
@@ -68,6 +69,12 @@ struct goacc_thread
strictly push/pop semantics according to lexical scope. */
struct target_mem_desc *mapped_data;
+ /* Data of the OpenACC Profiling Interface. */
+ acc_prof_info *prof_info;
+ acc_api_info *api_info;
+ /* Per-thread toggle of OpenACC Profiling Interface callbacks. */
+ bool prof_callbacks_enabled;
+
/* These structures form a list: this is the next thread in that list. */
struct goacc_thread *next;
@@ -128,6 +135,13 @@ async_synchronous_p (int async)
return async == acc_async_sync;
}
+void goacc_profiling_initialize (void);
+bool goacc_profiling_setup_p (struct goacc_thread *,
+ acc_prof_info *, acc_api_info *);
+bool goacc_profiling_dispatch_p (bool);
+void goacc_profiling_dispatch (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+
#ifdef HAVE_ATTRIBUTE_VISIBILITY
# pragma GCC visibility pop
#endif
diff --git a/libgomp/oacc-mem.c b/libgomp/oacc-mem.c
index b3b3777..1922f38 100644
--- a/libgomp/oacc-mem.c
+++ b/libgomp/oacc-mem.c
@@ -99,12 +99,30 @@ acc_malloc (size_t s)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
assert (thr->dev);
+ void *ret;
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- return malloc (s);
+ {
+ /* TODO: Should we also generate acc_ev_alloc here? */
+ ret = malloc (s);
+ }
+ else
+ ret = thr->dev->alloc_func (thr->dev->target_id, s);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
- return thr->dev->alloc_func (thr->dev->target_id, s);
+ return ret;
}
/* OpenACC 2.0a (3.2.16) doesn't specify what to do in the event
@@ -120,12 +138,23 @@ acc_free (void *d)
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
assert (thr && thr->dev);
struct gomp_device_descr *acc_dev = thr->dev;
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- return free (d);
+ {
+ /* TODO: Should we also generate acc_ev_free here? */
+ free (d);
+
+ goto out;
+ }
gomp_mutex_lock (&acc_dev->lock);
@@ -147,6 +176,13 @@ acc_free (void *d)
if (!acc_dev->free_func (acc_dev->target_id, d))
gomp_fatal ("error in freeing device memory in %s", __FUNCTION__);
+
+ out:
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
@@ -157,15 +193,31 @@ memcpy_tofrom_device (bool from, void *d, void *h, size_t s, int async,
been obtained from a routine that did that. */
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
assert (thr && thr->dev);
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
{
+ /* TODO: Should we also generate
+ acc_ev_enqueue_upload_start/acc_ev_enqueue_upload_end or
+ acc_ev_enqueue_download_start/acc_ev_enqueue_download_end here? */
if (from)
memmove (h, d, s);
else
memmove (d, h, s);
- return;
+
+ goto out;
}
goacc_aq aq = get_goacc_asyncqueue (async);
@@ -173,6 +225,13 @@ memcpy_tofrom_device (bool from, void *d, void *h, size_t s, int async,
gomp_copy_dev2host (thr->dev, aq, h, d, s);
else
gomp_copy_host2dev (thr->dev, aq, d, h, s, /* TODO: cbuf? */ NULL);
+
+out:
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -217,6 +276,9 @@ acc_deviceptr (void *h)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&dev->lock);
n = lookup_host (dev, h, 1);
@@ -254,6 +316,9 @@ acc_hostptr (void *d)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return d;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_dev (&acc_dev->mem_map, d, 1);
@@ -291,6 +356,9 @@ acc_is_present (void *h, size_t s)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h != NULL;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -322,6 +390,12 @@ acc_map_data (void *h, void *d, size_t s)
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
{
if (d != h)
@@ -357,6 +431,12 @@ acc_map_data (void *h, void *d, size_t s)
&kinds, true, GOMP_MAP_VARS_OPENACC);
tgt->list[0].key->refcount = REFCOUNT_INFINITY;
}
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -372,6 +452,12 @@ acc_unmap_data (void *h)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+
gomp_mutex_lock (&acc_dev->lock);
cur_node.host_start = (uintptr_t) h;
@@ -405,6 +491,12 @@ acc_unmap_data (void *h)
}
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
#define FLAG_PRESENT (1 << 0)
@@ -428,6 +520,18 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -489,6 +593,12 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
gomp_mutex_unlock (&acc_dev->lock);
}
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return d;
}
@@ -569,6 +679,18 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -627,6 +749,12 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
}
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -700,6 +828,18 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
gomp_mutex_lock (&acc_dev->lock);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
n = lookup_host (acc_dev, h, s);
if (!n)
@@ -719,6 +859,12 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
gomp_copy_dev2host (acc_dev, aq, h, d, s);
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
diff --git a/libgomp/oacc-parallel.c b/libgomp/oacc-parallel.c
index b949599..670c62c 100644
--- a/libgomp/oacc-parallel.c
+++ b/libgomp/oacc-parallel.c
@@ -205,22 +205,81 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
thr = goacc_thread ();
acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_compute_construct_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info compute_construct_event_info;
+ if (profiling_dispatch_p)
+ {
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ compute_construct_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ compute_construct_event_info.other_event.parent_construct
+ = acc_construct_parallel; //TODO: kernels...
+ compute_construct_event_info.other_event.implicit = 0;
+ compute_construct_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds);
/* Host fallback if "if" clause is false or if the current device is set to
the host. */
if (flags & GOACC_FLAG_HOST_FALLBACK)
{
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
goacc_save_and_set_bind (acc_device_host);
goacc_call_host_fn (fn, mapnum, hostaddrs, params);
goacc_restore_bind ();
- return;
+ goto out;
}
else if (acc_device_type (acc_dev->type) == acc_device_host)
{
goacc_call_host_fn (fn, mapnum, hostaddrs, params);
- return;
+ goto out;
}
+ else if (profiling_dispatch_p)
+ api_info.device_api = acc_device_api_cuda;
/* Default: let the runtime choose. */
for (i = 0; i != GOMP_DIM_MAX; i++)
@@ -252,6 +311,14 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
if (async == GOMP_LAUNCH_OP_MAX)
async = va_arg (*ap, unsigned);
+
+ if (profiling_dispatch_p)
+ {
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
break;
}
@@ -284,10 +351,34 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
else
tgt_fn = (void (*)) fn;
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_start;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = compute_construct_event_info.other_event.parent_construct;
+ enter_exit_data_event_info.other_event.implicit = 1;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
+
goacc_aq aq = get_goacc_asyncqueue (async);
tgt = gomp_map_vars_async (acc_dev, aq, mapnum, hostaddrs, NULL, sizes, kinds,
true, GOMP_MAP_VARS_OPENACC);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
#ifdef RC_CHECKING
gomp_mutex_lock (&acc_dev->lock);
@@ -310,8 +401,25 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
else
acc_dev->openacc.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs,
dims, tgt);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_start;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
/* If running synchronously, unmap immediately. */
gomp_unmap_vars (tgt, true);
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
}
else
{
@@ -329,6 +437,19 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
gomp_rc_check (acc_dev, thr->mapped_data);
gomp_mutex_unlock (&acc_dev->lock);
#endif
+
+out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_compute_construct_end;
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -390,6 +511,72 @@ GOACC_data_start (int flags_m, size_t mapnum,
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_enter_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info enter_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ enter_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_data_event_info.other_event.parent_construct = acc_construct_data;
+ for (int i = 0; i < mapnum; ++i)
+ if (kinds[i] == GOMP_MAP_USE_DEVICE_PTR)
+ {
+ /* If there is one such data mapping kind, then this is actually an
+ OpenACC host_data construct. (GCC maps the OpenACC host_data
+ construct to the OpenACC data construct.) Apart from artificial
+ test cases (such as an OpenACC host_data construct's (implicit)
+ device initialization when there hasn't been any device data be
+ set up before...), there can't really any meaningful events be
+ generated from OpenACC host_data constructs, though. */
+ enter_data_event_info.other_event.parent_construct
+ = acc_construct_host_data;
+ break;
+ }
+ enter_data_event_info.other_event.implicit = 0;
+ enter_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds);
enum gomp_map_vars_kind pragma_kind;
@@ -402,11 +589,14 @@ GOACC_data_start (int flags_m, size_t mapnum,
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| (flags & GOACC_FLAG_HOST_FALLBACK))
{
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
tgt = gomp_map_vars (NULL, 0, NULL, NULL, NULL, NULL, true, pragma_kind);
tgt->prev = thr->mapped_data;
thr->mapped_data = tgt;
- return;
+ goto out;
}
gomp_debug (0, " %s: prepare mappings\n", __FUNCTION__);
@@ -421,14 +611,78 @@ GOACC_data_start (int flags_m, size_t mapnum,
gomp_rc_check (acc_dev, thr->mapped_data);
gomp_mutex_unlock (&acc_dev->lock);
#endif
+
+out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_data_end (void)
{
struct goacc_thread *thr = goacc_thread ();
+ struct gomp_device_descr *acc_dev = thr->dev;
struct target_mem_desc *tgt = thr->mapped_data;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ exit_data_event_info.other_event.parent_construct = acc_construct_data;
+ exit_data_event_info.other_event.implicit = 0;
+ exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
gomp_debug (0, " %s: restore mappings\n", __FUNCTION__);
thr->mapped_data = tgt->prev;
gomp_unmap_vars (tgt, true);
@@ -439,6 +693,16 @@ GOACC_data_end (void)
gomp_rc_check (thr->dev, thr->mapped_data);
gomp_mutex_unlock (&thr->dev->lock);
#endif
+
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_end;
+ exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -453,24 +717,6 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
bool data_enter = false;
size_t i;
- goacc_lazy_initialize ();
-
- thr = goacc_thread ();
- acc_dev = thr->dev;
-
- if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- || (flags & GOACC_FLAG_HOST_FALLBACK))
- return;
-
- if (num_waits)
- {
- va_list ap;
-
- va_start (ap, num_waits);
- goacc_wait (async, num_waits, &ap);
- va_end (ap);
- }
-
/* Determine whether "finalize" semantics apply to all mappings of this
OpenACC directive. */
bool finalize = false;
@@ -521,6 +767,86 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
kind);
}
+ goacc_lazy_initialize ();
+
+ thr = goacc_thread ();
+ acc_dev = thr->dev;
+
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type
+ = data_enter ? acc_ev_enter_data_start : acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_dispatch_p)
+ {
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = data_enter ? acc_construct_enter_data : acc_construct_exit_data;
+ enter_exit_data_event_info.other_event.implicit = 0;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
+ || (flags & GOACC_FLAG_HOST_FALLBACK))
+ {
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+ goto out;
+ }
+
+ if (num_waits > 0)
+ {
+ va_list ap;
+
+ va_start (ap, num_waits);
+ goacc_wait (async, num_waits, &ap);
+ va_end (ap);
+ }
+ else if (num_waits == acc_async_noval)
+ acc_wait_all_async (async);
+
/* In c, non-pointers and arrays are represented by a single data clause.
Dynamically allocated arrays and subarrays are represented by a data
clause followed by an internal GOMP_MAP_POINTER.
@@ -739,6 +1065,18 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
gomp_rc_check (acc_dev, thr->mapped_data);
gomp_mutex_unlock (&acc_dev->lock);
#endif
+
+out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = data_enter ? acc_ev_enter_data_end: acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
@@ -787,9 +1125,66 @@ GOACC_update (int flags_m, size_t mapnum,
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (true), false);
+
+ acc_prof_info prof_info;
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_update_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1; //TODO
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL; //TODO
+ prof_info.func_name = NULL; //TODO
+ prof_info.line_no = -1; //TODO
+ prof_info.end_line_no = -1; //TODO
+ prof_info.func_line_no = -1; //TODO
+ prof_info.func_end_line_no = -1; //TODO
+ }
+ acc_event_info update_event_info;
+ if (profiling_dispatch_p)
+ {
+ update_event_info.other_event.event_type
+ = prof_info.event_type;
+ update_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ update_event_info.other_event.parent_construct = acc_construct_update;
+ update_event_info.other_event.implicit = 0;
+ update_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_dispatch_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1; //TODO
+ api_info.device_handle = NULL; //TODO
+ api_info.context_handle = NULL; //TODO
+ api_info.async_handle = NULL; //TODO
+ }
+
+ if (profiling_dispatch_p)
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| (flags & GOACC_FLAG_HOST_FALLBACK))
- return;
+ {
+ //TODO
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+ goto out;
+ }
if (num_waits)
{
@@ -861,11 +1256,41 @@ GOACC_update (int flags_m, size_t mapnum,
break;
}
}
+
+out:
+ if (profiling_dispatch_p)
+ {
+ prof_info.event_type = acc_ev_update_end;
+ update_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_wait (int async, int num_waits, ...)
{
+ goacc_lazy_initialize ();
+
+ struct goacc_thread *thr = goacc_thread ();
+
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_setup_p
+ = __builtin_expect (goacc_profiling_setup_p (thr, &prof_info, &api_info),
+ false);
+ if (profiling_setup_p)
+ {
+ prof_info.async = async;
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info.async_queue = prof_info.async;
+ }
+
if (num_waits)
{
va_list ap;
@@ -878,6 +1303,12 @@ GOACC_wait (int async, int num_waits, ...)
acc_wait_all ();
else
acc_wait_all_async (async);
+
+ if (profiling_setup_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
int
diff --git a/libgomp/oacc-plugin.c b/libgomp/oacc-plugin.c
index 5480c1d..a04abb0 100644
--- a/libgomp/oacc-plugin.c
+++ b/libgomp/oacc-plugin.c
@@ -47,6 +47,19 @@ GOMP_PLUGIN_acc_thread (void)
return thr ? thr->target_tls : NULL;
}
+/* Return the TLS data for the current thread. */
+/* TODO. Should we be able to directly call (the static inline function)
+ goacc_thread from within plugin code? I didn't manage to get the
+ "goacc_tls_data" symbol configured correctly: "[...]/ld:
+ .libs/libgomp-plugin-nvptx.so.1.0.0: hidden symbol `goacc_tls_data' isn't
+ defined". */
+
+struct goacc_thread *
+GOMP_PLUGIN_goacc_thread (void)
+{
+ return goacc_thread ();
+}
+
int
GOMP_PLUGIN_acc_default_dim (unsigned int i)
{
diff --git a/libgomp/oacc-plugin.h b/libgomp/oacc-plugin.h
index 112d4a59..112d3cd 100644
--- a/libgomp/oacc-plugin.h
+++ b/libgomp/oacc-plugin.h
@@ -27,8 +27,11 @@
#ifndef OACC_PLUGIN_H
#define OACC_PLUGIN_H 1
+#include "oacc-int.h"
+
extern void GOMP_PLUGIN_async_unmap_vars (void *, int);
extern void *GOMP_PLUGIN_acc_thread (void);
+extern struct goacc_thread *GOMP_PLUGIN_goacc_thread (void);
extern int GOMP_PLUGIN_acc_default_dim (unsigned int);
#endif
diff --git a/libgomp/oacc-profiling-acc_register_library.c b/libgomp/oacc-profiling-acc_register_library.c
new file mode 100644
index 0000000..f6b482b
--- /dev/null
+++ b/libgomp/oacc-profiling-acc_register_library.c
@@ -0,0 +1,39 @@
+/* Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+/* This file provides an stub acc_register_library function. It's in a
+ separate file so that this function can easily be overridden when linking
+ statically. */
+
+#include "libgomp.h"
+#include "acc_prof.h"
+
+void
+acc_register_library (acc_prof_reg reg, acc_prof_reg unreg,
+ acc_prof_lookup_func lookup)
+{
+ gomp_debug (0, "dummy %s\n", __FUNCTION__);
+}
diff --git a/libgomp/oacc-profiling.c b/libgomp/oacc-profiling.c
new file mode 100644
index 0000000..5542d6a
--- /dev/null
+++ b/libgomp/oacc-profiling.c
@@ -0,0 +1,666 @@
+/* Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+/* OpenACC Profiling Interface. */
+
+#include "libgomp.h"
+#include "oacc-int.h"
+#include "acc_prof.h"
+#include <assert.h>
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+#ifdef PLUGIN_SUPPORT
+# include <dlfcn.h>
+#endif
+
+#define STATIC_ASSERT(expr) _Static_assert (expr, "!(" #expr ")")
+
+/* Statically assert that the layout of the common fields in the
+ "acc_event_info" variants matches. */
+/* event_type */
+STATIC_ASSERT (offsetof (acc_event_info, event_type)
+ == offsetof (acc_event_info, data_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, launch_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, other_event.event_type));
+/* valid_bytes */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, launch_event.valid_bytes));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, other_event.valid_bytes));
+/* parent_construct */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, launch_event.parent_construct));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, other_event.parent_construct));
+/* implicit */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, launch_event.implicit));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, other_event.implicit));
+/* tool_info */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, launch_event.tool_info));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, other_event.tool_info));
+
+struct goacc_prof_callback_entry
+{
+ acc_prof_callback cb;
+ int ref;
+ bool enabled;
+ struct goacc_prof_callback_entry *next;
+};
+
+/* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global toggle. */
+static bool goacc_prof_callbacks_enabled[acc_ev_last];
+static struct goacc_prof_callback_entry *goacc_prof_callback_entries[acc_ev_last];
+
+/* This lock is used to protect access to goacc_prof_callbacks_enabled, and
+ goacc_prof_callback_entries. */
+static gomp_mutex_t goacc_prof_lock;
+
+void
+goacc_profiling_initialize (void)
+{
+ gomp_mutex_init (&goacc_prof_lock);
+
+ /* Initially, all callbacks for all events are enabled. */
+ for (int i = 0; i < acc_ev_last; ++i)
+ goacc_prof_callbacks_enabled[i] = true;
+
+ /* We are to invoke an external acc_register_library routine, defaulting to
+ our stub oacc-profiling-acc_register_library.c:acc_register_library
+ implementation. */
+ gomp_debug (0, "%s: calling acc_register_library\n", __FUNCTION__);
+ //TODO.
+ acc_register_library (acc_prof_register, acc_prof_unregister, NULL);
+#ifdef PLUGIN_SUPPORT
+ char *acc_proflibs = getenv ("ACC_PROFLIB");
+ while (acc_proflibs != NULL && acc_proflibs[0] != '\0')
+ {
+ char *acc_proflibs_sep = strchr (acc_proflibs, ';');
+ char *acc_proflib;
+ if (acc_proflibs_sep == acc_proflibs)
+ {
+ /* Stray ";" separator: make sure we don't dlopen the main
+ program. */
+ acc_proflib = NULL;
+ }
+ else
+ {
+ if (acc_proflibs_sep != NULL)
+ {
+ /* Single out the first library. */
+ acc_proflib = gomp_malloc (acc_proflibs_sep - acc_proflibs + 1);
+ memcpy (acc_proflib, acc_proflibs,
+ acc_proflibs_sep - acc_proflibs);
+ acc_proflib[acc_proflibs_sep - acc_proflibs] = '\0';
+ }
+ else
+ {
+ /* No ";" separator, so only one library. */
+ acc_proflib = acc_proflibs;
+ }
+
+ gomp_debug (0, "%s: dlopen(%s)\n", __FUNCTION__, acc_proflib);
+ void *dl_handle = dlopen (acc_proflib, RTLD_LAZY);
+ if (dl_handle != NULL)
+ {
+ typeof (&acc_register_library) a_r_l
+ = dlsym (dl_handle, "acc_register_library");
+ if (a_r_l == NULL)
+ goto dl_fail;
+ /* Avoid duplicate registration, for example if the same shared
+ library is specified in LD_PRELOAD and ACC_PROFLIB -- which
+ TAU 2.26 does when using "tau_exec -openacc". */
+ if (a_r_l != acc_register_library)
+ {
+ gomp_debug (0, " %s: calling %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ //TODO.
+ a_r_l (acc_prof_register, acc_prof_unregister, NULL);
+ }
+ else
+ gomp_debug (0, " %s: skipping duplicate"
+ " %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ }
+ else
+ {
+ dl_fail:
+ gomp_error ("while loading ACC_PROFLIB %s: %s",
+ acc_proflib, dlerror ());
+ if (dl_handle != NULL)
+ {
+ int err = dlclose (dl_handle);
+ dl_handle = NULL;
+ if (err != 0)
+ goto dl_fail;
+ }
+ }
+ }
+
+ if (acc_proflib != acc_proflibs)
+ {
+ free (acc_proflib);
+
+ acc_proflibs = acc_proflibs_sep + 1;
+ }
+ else
+ acc_proflibs = NULL;
+ }
+#endif /* PLUGIN_SUPPORT */
+}
+
+void
+acc_prof_register (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ //TODO
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+ enum
+ {
+ EVENT_KIND_BOGUS,
+ EVENT_KIND_NORMAL,
+ /* As end events invoke callbacks in the reverse order, we register these
+ in the reverse order here. */
+ EVENT_KIND_END,
+ } event_kind = EVENT_KIND_BOGUS;
+ switch (ev)
+ {
+ case acc_ev_none:
+ case acc_ev_device_init_start:
+ case acc_ev_device_shutdown_start:
+ case acc_ev_runtime_shutdown:
+ case acc_ev_create:
+ case acc_ev_delete:
+ case acc_ev_alloc:
+ case acc_ev_free:
+ case acc_ev_enter_data_start:
+ case acc_ev_exit_data_start:
+ case acc_ev_update_start:
+ case acc_ev_compute_construct_start:
+ case acc_ev_enqueue_launch_start:
+ case acc_ev_enqueue_upload_start:
+ case acc_ev_enqueue_download_start:
+ case acc_ev_wait_start:
+ event_kind = EVENT_KIND_NORMAL;
+ break;
+ case acc_ev_device_init_end:
+ case acc_ev_device_shutdown_end:
+ case acc_ev_enter_data_end:
+ case acc_ev_exit_data_end:
+ case acc_ev_update_end:
+ case acc_ev_compute_construct_end:
+ case acc_ev_enqueue_launch_end:
+ case acc_ev_enqueue_upload_end:
+ case acc_ev_enqueue_download_end:
+ case acc_ev_wait_end:
+ event_kind = EVENT_KIND_END;
+ break;
+ case acc_ev_last:
+ break;
+ }
+ if (event_kind == EVENT_KIND_BOGUS)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request for TODOinvalid acc_event_t %d",
+ __FUNCTION__, /* TODO */ (int) ev);
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request with TODOinvalid acc_register_t %d",
+ __FUNCTION__, /* TODO */ (int) reg);
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally enabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global
+ toggle. */
+ goacc_prof_callbacks_enabled[ev] = true;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ /* Silently ignore request. */
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: enabling callbacks\n");
+ goacc_lazy_initialize ();
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = true;
+ return;
+ }
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these?
+ gomp_error ("ignoring %s request for acc_toggle_per_thread with TODO",
+ __FUNCTION__);
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ /* If we already have this callback registered, just increment its ref
+ count. */
+ if (it != NULL)
+ {
+ it->ref++;
+ gomp_debug (0, " already registered;"
+ " incrementing ref count to: %d\n", it->ref);
+ }
+ else
+ {
+ struct goacc_prof_callback_entry *e
+ = gomp_malloc (sizeof (struct goacc_prof_callback_entry));
+ e->cb = cb;
+ e->ref = 1;
+ e->enabled = true;
+ bool prepend = (event_kind == EVENT_KIND_END);
+ /* If we don't have any callback registered yet, also use the
+ "prepend" code path. */
+ if (it_p == NULL)
+ prepend = true;
+ if (prepend)
+ {
+ gomp_debug (0, " prepending\n");
+ e->next = goacc_prof_callback_entries[ev];
+ goacc_prof_callback_entries[ev] = e;
+ }
+ else
+ {
+ gomp_debug (0, " appending\n");
+ e->next = NULL;
+ it_p->next = e;
+ }
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ /* Silently ignore acc_toggle request if not registered. */
+ gomp_debug (0, " not enabling; not registered\n");
+ }
+ else
+ {
+ gomp_debug (0, " enabling\n");
+ it->enabled = true;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+void
+acc_prof_unregister (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ //TODO
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+ if (ev < acc_ev_none
+ || ev >= acc_ev_last)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request for TODOinvalid acc_event_t %d",
+ __FUNCTION__, /* TODO */ (int) ev);
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these, for forward compatibility?
+ gomp_error ("ignoring %s request with TODOinvalid acc_register_t %d",
+ __FUNCTION__, /* TODO */ (int) reg);
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally disabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global
+ toggle. */
+ goacc_prof_callbacks_enabled[ev] = false;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ /* Silently ignore request. */
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: disabling callbacks\n");
+ goacc_lazy_initialize ();
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = false;
+ return;
+ }
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these?
+ gomp_error ("ignoring %s request for acc_toggle_per_thread with TODO",
+ __FUNCTION__);
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ if (it == NULL)
+ {
+ //TODO: should this be a fatal error? Or, should we (silently?) ignore these?
+ gomp_error ("ignoring %s request for acc_event_t %d: not registered",
+ __FUNCTION__, /* TODO */ (int) ev);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ it->ref--;
+ gomp_debug (0, " decrementing ref count to: %d\n", it->ref);
+ if (it->ref == 0)
+ {
+ if (it_p == NULL)
+ goacc_prof_callback_entries[ev] = it->next;
+ else
+ it_p->next = it->next;
+ free (it);
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ /* Silently ignore acc_toggle request if not registered. */
+ gomp_debug (0, " not disabling; not registered\n");
+ }
+ else
+ {
+ gomp_debug (0, " disabling\n");
+ it->enabled = false;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+/* Set up to dispatch events? */
+
+bool
+goacc_profiling_setup_p (struct goacc_thread *thr,
+ acc_prof_info *prof_info, acc_api_info *api_info)
+{
+ //TODO
+ gomp_debug (0, "%s (%p)\n", __FUNCTION__, thr);
+
+ /* If we don't have any per-thread state yet, we can't register prof_info and
+ api_info. */
+ /* TODO: In this case, should we actually call goacc_lazy_initialize here,
+ and return the "thr" from goacc_profiling_setup_p? */
+ if (__builtin_expect (thr == NULL, false))
+ {
+ //TODO
+ gomp_debug (0, "Can't generate OpenACC Profiling Interface events for"
+ " the current call, construct, or directive\n");
+ return false;
+ }
+
+ bool profiling_dispatch_p
+ = __builtin_expect (goacc_profiling_dispatch_p (false), false);
+ if (thr->prof_info != NULL)
+ {
+ assert (profiling_dispatch_p); //TODO
+ /* Profiling has already been set up for an outer construct. In this
+ case, we continue to use the existing information, and thus return
+ "false" here.
+
+ This can happen, for example, for an enter data directive, which sets
+ up profiling, then calls into acc_copyin, which should not again set
+ up profiling, should not overwrite the existing information. */
+ //TODO: Is this all kosher?
+ return false;
+ }
+
+ if (profiling_dispatch_p)
+ {
+ thr->prof_info = prof_info;
+
+ prof_info->event_type = -1; /* Must be set later. */
+ prof_info->valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info->version = _ACC_PROF_INFO_VERSION;
+ //TODO
+ if (thr->dev)
+ {
+ prof_info->device_type = acc_device_type (thr->dev->type);
+ prof_info->device_number = thr->dev->target_id;
+ }
+ else
+ {
+ prof_info->device_type = -1;
+ prof_info->device_number = -1;
+ }
+ prof_info->thread_id = -1; //TODO
+ prof_info->async = acc_async_sync; //TODO
+ /* See <https://github.com/OpenACC/openacc-spec/issues/71>. */
+ prof_info->async_queue = prof_info->async;
+ prof_info->src_file = NULL; //TODO
+ prof_info->func_name = NULL; //TODO
+ prof_info->line_no = -1; //TODO
+ prof_info->end_line_no = -1; //TODO
+ prof_info->func_line_no = -1; //TODO
+ prof_info->func_end_line_no = -1; //TODO
+
+ thr->api_info = api_info;
+
+ api_info->device_api = acc_device_api_none; //TODO
+ api_info->valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info->device_type = prof_info->device_type;
+ api_info->vendor = -1; //TODO
+ api_info->device_handle = NULL; //TODO
+ api_info->context_handle = NULL; //TODO
+ api_info->async_handle = NULL; //TODO
+ }
+
+ return profiling_dispatch_p;
+}
+
+/* Prepare to dispatch events? */
+
+bool
+goacc_profiling_dispatch_p (bool check_not_nested_p)
+{
+ //TODO
+ gomp_debug (0, "%s\n", __FUNCTION__);
+
+ struct goacc_thread *thr = goacc_thread ();
+ if (__builtin_expect (thr == NULL, false))
+ {
+ /* If we don't have any per-thread state yet, that means that per-thread
+ callback dispatch has not been explicitly disabled (which only a call
+ to acc_prof_unregister with acc_toggle_per_thread will do, and that
+ would have allocated per-thread state via goacc_lazy_initialize);
+ initially, all callbacks for all events are enabled. */
+ //TODO
+ gomp_debug (0, " %s: don't have any per-thread state yet\n", __FUNCTION__);
+ }
+ else
+ {
+ if (check_not_nested_p)
+ {
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ }
+
+ if (__builtin_expect (!thr->prof_callbacks_enabled, true))
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled for this thread\n", __FUNCTION__);
+ return false;
+ }
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ /* goacc_prof_callbacks_enabled[acc_ev_none] acts as a global toggle. */
+ if (__builtin_expect (!goacc_prof_callbacks_enabled[acc_ev_none], true))
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled globally\n", __FUNCTION__);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return false;
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+
+ return true;
+}
+
+/* Dispatch events.
+
+ TODO.
+ This must only be called if goacc_profiling_dispatch_p returned a true
+ result. */
+
+void
+goacc_profiling_dispatch (acc_prof_info *prof_info, acc_event_info *event_info,
+ acc_api_info *apt_info)
+{
+ acc_event_t event_type = event_info->event_type;
+ //TODO
+ gomp_debug (0, "%s: event_type=%d\n", __FUNCTION__, (int) event_type);
+ //TODO
+ assert (event_type > acc_ev_none
+ && event_type < acc_ev_last);
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ if (!goacc_prof_callbacks_enabled[event_type])
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled for this event type\n", __FUNCTION__);
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+
+ for (struct goacc_prof_callback_entry *e
+ = goacc_prof_callback_entries[event_type];
+ e != NULL;
+ e = e->next)
+ {
+ if (!e->enabled)
+ {
+ //TODO
+ gomp_debug (0, " %s: disabled for callback %p\n",
+ __FUNCTION__, e->cb);
+ continue;
+ }
+
+ //TODO
+ gomp_debug (0, " %s: calling callback %p\n", __FUNCTION__, e->cb);
+ e->cb (prof_info, event_info, apt_info);
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
diff --git a/libgomp/plugin/plugin-nvptx.c b/libgomp/plugin/plugin-nvptx.c
index cb18e87..1b6f2d4 100644
--- a/libgomp/plugin/plugin-nvptx.c
+++ b/libgomp/plugin/plugin-nvptx.c
@@ -37,6 +37,7 @@
#include "libgomp-plugin.h"
#include "oacc-plugin.h"
#include "gomp-constants.h"
+#include "oacc-int.h"
#include <pthread.h>
#include <cuda.h>
@@ -903,11 +904,54 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
// num_gangs nctaid.x
// num_workers ntid.y
// vector length ntid.x
+
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info enqueue_launch_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_start;
+
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ enqueue_launch_event_info.launch_event.valid_bytes
+ = _ACC_LAUNCH_EVENT_INFO_VALID_BYTES;
+ enqueue_launch_event_info.launch_event.parent_construct
+ /* TODO = compute_construct_event_info.other_event.parent_construct */
+ = acc_construct_parallel; //TODO: kernels...
+ enqueue_launch_event_info.launch_event.implicit = 1;
+ enqueue_launch_event_info.launch_event.tool_info = NULL;
+ enqueue_launch_event_info.launch_event.kernel_name
+ = /* TODO */ (char *) /* TODO */ targ_fn->launch->fn;
+ enqueue_launch_event_info.launch_event.num_gangs
+ = dims[GOMP_DIM_GANG];
+ enqueue_launch_event_info.launch_event.num_workers
+ = dims[GOMP_DIM_WORKER];
+ enqueue_launch_event_info.launch_event.vector_length
+ = dims[GOMP_DIM_VECTOR];
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
+
CUDA_CALL_ASSERT (cuLaunchKernel, function,
dims[GOMP_DIM_GANG], 1, 1,
dims[GOMP_DIM_VECTOR], dims[GOMP_DIM_WORKER], 1,
0, stream, kargs, 0);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_end;
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
+
GOMP_PLUGIN_debug (0, " %s: kernel %s: finished\n", __FUNCTION__,
targ_fn->launch->fn);
}
@@ -920,6 +964,36 @@ nvptx_alloc (size_t s)
CUdeviceptr d;
CUDA_CALL_ERET (NULL, cuMemAlloc, &d, s);
+
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ bool profiling_dispatch_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_alloc;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ data_event_info.data_event.implicit = 1; //TODO
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = s;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = (void *) d;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
return (void *) d;
}
@@ -950,6 +1024,36 @@ nvptx_free (void *p, struct ptx_device *ptx_dev)
}
CUDA_CALL (cuMemFree, (CUdeviceptr) p);
+
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ bool profiling_dispatch_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_free;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ data_event_info.data_event.implicit = 1; //TODO
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = ps;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = p;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
return true;
}
@@ -1355,10 +1459,47 @@ openacc_exec_internal (void (*fn) (void *), int params, size_t mapnum,
/* Copy the (device) pointers to arguments to the device (dp and hp might in
fact have the same value on a unified-memory system). */
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ /* Always implicit for "data mapping arguments for cuLaunchKernel". */
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = mapnum * sizeof (void *);
+ data_event_info.data_event.host_ptr = hp;
+ if (!params)
+ data_event_info.data_event.device_ptr = (void *) dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
if (!params && mapnum > 0)
CUDA_CALL_ASSERT (cuMemcpyHtoD, dp, (void *) hp,
mapnum * sizeof (void *));
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
if (params)
nvptx_exec (fn, mapnum, hostaddrs, devaddrs, dims, targ_mem_desc,
hp, NULL);
@@ -1439,6 +1580,35 @@ openacc_async_exec_internal (void (*fn) (void *), int params, size_t mapnum,
/* Copy the (device) pointers to arguments to the device (dp and hp might in
fact have the same value on a unified-memory system). */
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_dispatch_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel; //TODO
+ /* Always implicit for "data mapping arguments for cuLaunchKernel". */
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL; //TODO
+ data_event_info.data_event.bytes = mapnum * sizeof (void *);
+ data_event_info.data_event.host_ptr = hp;
+ if (!params)
+ data_event_info.data_event.device_ptr = (void *) dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
if (!params && mapnum > 0)
{
CUDA_CALL_ASSERT (cuMemcpyHtoDAsync, dp, (void *) hp,
@@ -1450,6 +1620,14 @@ openacc_async_exec_internal (void (*fn) (void *), int params, size_t mapnum,
block[1] = (void *) nvthd->ptx_dev;
}
+ if (profiling_dispatch_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
if (params)
nvptx_exec (fn, mapnum, hostaddrs, devaddrs, dims, targ_mem_desc,
hp, aq->cuda_stream);
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
new file mode 100644
index 0000000..4c1f2bb
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
@@ -0,0 +1,344 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+void cb_compute_construct_start_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 10
+ || state == 30
+ || state == 41
+ || state == 51
+ || state == 91
+ || state == 101
+ || state == 151);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_start_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 11
+ || state == 40
+ || state == 50
+ || state == 90
+ || state == 100
+ || state == 150);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 14
+ || state == 21
+ || state == 32
+ || state == 42
+ || state == 80
+ || state == 103
+ || state == 152);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 13
+ || state == 43
+ || state == 102
+ || state == 154);
+ STATE_OP (state, ++);
+}
+
+void cb_compute_construct_end_3 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 12
+ || state == 20
+ || state == 31
+ || state == 44
+ || state == 81
+ || state == 104
+ || state == 153);
+ STATE_OP (state, ++);
+}
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 2);
+ }
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 12);
+ }
+ assert (state == 15);
+
+ STATE_OP (state, = 20);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 20);
+ }
+ assert (state == 20);
+
+ STATE_OP (state, = 30);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 31);
+ }
+ assert (state == 33);
+
+ STATE_OP (state, = 40);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 42);
+ }
+ assert (state == 45);
+
+ STATE_OP (state, = 50);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 52);
+ }
+ assert (state == 52);
+
+ STATE_OP (state, = 60);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 60);
+ }
+ assert (state == 60);
+
+ STATE_OP (state, = 70);
+ unreg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 70);
+ }
+ assert (state == 70);
+
+ STATE_OP (state, = 80);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 80);
+ }
+ assert (state == 82);
+
+ STATE_OP (state, = 90);
+ reg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 92);
+ }
+ assert (state == 92);
+
+ STATE_OP (state, = 100);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 102);
+ }
+ assert (state == 105);
+
+ STATE_OP (state, = 110);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 110);
+ }
+ assert (state == 110);
+
+ STATE_OP (state, = 120);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 120);
+ }
+ assert (state == 120);
+
+ STATE_OP (state, = 130);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 130);
+ }
+ assert (state == 130);
+
+ STATE_OP (state, = 140);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 140);
+ }
+ assert (state == 140);
+
+ STATE_OP (state, = 150);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 152);
+ }
+ assert (state == 155);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
new file mode 100644
index 0000000..436f436
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
@@ -0,0 +1,306 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 1)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 2)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 10
+ || state == 110);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 11
+ || state == 111);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ assert (state == 0);
+
+ acc_init (acc_device_host);
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = 12;
+
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 11);
+ }
+ assert (state == 12);
+
+ STATE_OP (state, = 90);
+ acc_shutdown (acc_device_host);
+ assert (state == 90);
+
+
+ STATE_OP (state, = 100);
+ acc_init (acc_device_default);
+ assert (state == 102);
+
+ STATE_OP (state, = 110);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = 12;
+
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 111);
+ }
+ assert (state == 112);
+
+ STATE_OP (state, = 190);
+ acc_shutdown (acc_device_default);
+ assert (state == 190);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
new file mode 100644
index 0000000..1a5b5fb
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
@@ -0,0 +1,253 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+/* See the "DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT" reference in
+ libgomp.texi. */
+#define DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT 0
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int num_gangs, num_workers, vector_length;
+static int async;
+
+void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 0);
+ STATE_OP (state, = 1);
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == NULL);
+ assert (event_info->launch_event.kernel_name != NULL);
+ {
+ char *s = strstr (event_info->launch_event.kernel_name, "main");
+ assert (s != NULL);
+ s = strstr (s, "omp_fn");
+ assert (s != NULL);
+ }
+ if (num_gangs < 1)
+ assert (event_info->launch_event.num_gangs >= 1);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.num_gangs == num_gangs);
+#else
+ /* No parallelized OpenACC kernels constructs, and unparallelized OpenACC
+ kernels constructs must get launched as 1 x 1 x 1 kernels. */
+ assert (event_info->launch_event.num_gangs == 1);
+#endif
+ }
+ if (num_workers < 1)
+ assert (event_info->launch_event.num_workers >= 1);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.num_workers == num_workers);
+#else
+ /* See num_gangs above. */
+ assert (event_info->launch_event.num_workers == 1);
+#endif
+ }
+ if (vector_length < 1)
+ assert (event_info->launch_event.vector_length >= 1);
+ else if (acc_device_type == acc_device_nvidia) /* ... is special. */
+ assert (event_info->launch_event.vector_length == 32);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.vector_length == vector_length);
+#else
+ /* See num_gangs above. */
+ assert (event_info->launch_event.vector_length == 1);
+#endif
+ }
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+}
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
+ assert (state == 0);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ assert (state == 0);
+
+ STATE_OP (state, = 0);
+ /* Implicit async. */
+ async = acc_async_noval;
+ /* Parallelism dimensions: compiler/runtime decides. */
+ num_gangs = num_workers = vector_length = 0;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No acc_ev_enqueue_launch_start. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ STATE_OP (state, = 0);
+ /* Explicit async: without argument. */
+ async = acc_async_noval;
+ /* Parallelism dimensions: literal. */
+ num_gangs = 30;
+ num_workers = 3;
+ vector_length = 5;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels \
+ async \
+ num_gangs (30) num_workers (3) vector_length (5)
+ /* { dg-prune-output "using vector_length \\(32\\), ignoring 5" } */
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No acc_ev_enqueue_launch_start. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ STATE_OP (state, = 0);
+ /* Explicit async: variable. */
+ async = 123;
+ /* Parallelism dimensions: variable. */
+ num_gangs = 22;
+ num_workers = 5;
+ vector_length = 7;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels \
+ async (async) \
+ num_gangs (num_gangs) num_workers (num_workers) vector_length (vector_length)
+ /* { dg-prune-output "using vector_length \\(32\\), ignoring runtime setting" } */
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No acc_ev_enqueue_launch_start. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
new file mode 100644
index 0000000..ef37ae9
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
@@ -0,0 +1,698 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+/* Use explicit copyin clauses, to work around firstprivate optimizations,
+ which will cause the value at the point of call to be used (*before* any
+ potential modifications done in callbacks), as opposed to its address being
+ taken, which then later gets dereferenced (*after* any modifications done in
+ callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+/* See the "DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT" reference in
+ libgomp.texi. */
+#define DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT 0
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+static int state = -1;
+#define STATE_OP(state, op)\
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+#else
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+#else
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+#endif
+}
+
+void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 2
+ || state == 102);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_device_init_start);
+#else
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (event_info->other_event.tool_info == tool_info->nested);
+#else
+ assert (event_info->other_event.tool_info == tool_info);
+#endif
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+#else
+ free (tool_info);
+ tool_info = NULL;
+#endif
+}
+
+void cb_enter_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 3
+ || state == 103);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enter_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_enter_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 4
+ || state == 104);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_enter_data_start);
+
+ assert (prof_info->event_type == acc_ev_enter_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+void cb_exit_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 7);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_exit_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_exit_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 8);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_exit_data_start);
+
+ assert (prof_info->event_type == acc_ev_exit_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 0
+ || state == 100);
+ if (state == 100)
+ {
+ /* Compensate for the missing acc_ev_device_init_start and
+ acc_ev_device_init_end. */
+ state += 2;
+ }
+#else
+ if (state == 100)
+ {
+ /* Compensate for the missing acc_ev_device_init_start and
+ acc_ev_device_init_end. */
+ state += 2;
+ }
+ assert (state == 2
+ || state == 102);
+#endif
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing acc_ev_enter_data_start. */
+ state += 1;
+ }
+}
+
+void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing acc_ev_enter_data_end. */
+ state += 1;
+ /* Compensate for the missing acc_ev_enqueue_launch_start and
+ acc_ev_enqueue_launch_end. */
+ state += 2;
+ /* Compensate for the missing acc_ev_exit_data_start and
+ acc_ev_exit_data_end. */
+ state += 2;
+ }
+ else if (acc_async != acc_async_sync)
+ {
+ /* Compensate for the missing acc_ev_exit_data_start and
+ acc_ev_exit_data_end. */
+ state += 2;
+ }
+ assert (state == 9
+ || state == 109);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 5
+ || state == 105);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == NULL);
+ assert (event_info->launch_event.kernel_name != NULL);
+ {
+ char *s = strstr (event_info->launch_event.kernel_name, "main");
+ assert (s != NULL);
+ s = strstr (s, "omp_fn");
+ assert (s != NULL);
+ }
+ assert (event_info->launch_event.num_gangs >= 1);
+ assert (event_info->launch_event.num_workers >= 1);
+ assert (event_info->launch_event.vector_length >= 1);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.launch_event.event_type = event_info->launch_event.event_type;
+ tool_info->nested->event_info.launch_event.kernel_name = strdup (event_info->launch_event.kernel_name);
+ tool_info->nested->event_info.launch_event.num_gangs = event_info->launch_event.num_gangs;
+ tool_info->nested->event_info.launch_event.num_workers = event_info->launch_event.num_workers;
+ tool_info->nested->event_info.launch_event.vector_length = event_info->launch_event.vector_length;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+void cb_enqueue_launch_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 6
+ || state == 106);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.launch_event.event_type == acc_ev_enqueue_launch_start);
+ assert (tool_info->nested->event_info.launch_event.kernel_name != NULL);
+ assert (tool_info->nested->event_info.launch_event.num_gangs >= 1);
+ assert (tool_info->nested->event_info.launch_event.num_workers >= 1);
+ assert (tool_info->nested->event_info.launch_event.vector_length >= 1);
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == tool_info->nested);
+ assert (event_info->launch_event.kernel_name != NULL);
+ assert (strcmp (event_info->launch_event.kernel_name, tool_info->nested->event_info.launch_event.kernel_name) == 0);
+ assert (event_info->launch_event.num_gangs == tool_info->nested->event_info.launch_event.num_gangs);
+ assert (event_info->launch_event.num_workers == tool_info->nested->event_info.launch_event.num_workers);
+ assert (event_info->launch_event.vector_length == tool_info->nested->event_info.launch_event.vector_length);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested->event_info.launch_event.kernel_name);
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+int main()
+{
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_enter_data_start, cb_enter_data_start, acc_reg);
+ reg (acc_ev_enter_data_end, cb_enter_data_end, acc_reg);
+ reg (acc_ev_exit_data_start, cb_exit_data_start, acc_reg);
+ reg (acc_ev_exit_data_end, cb_exit_data_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
+ reg (acc_ev_enqueue_launch_end, cb_enqueue_launch_end, acc_reg);
+ assert (state == 0);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = acc_async_sync;
+ assert (state == 0);
+
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 4);
+ }
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
+ assert (state == 10);
+
+ STATE_OP (state, = 100);
+
+ acc_async = 12;
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 104);
+ }
+ assert (state == 110);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
new file mode 100644
index 0000000..a952c7a
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
@@ -0,0 +1,172 @@
+/* Test the "valid_bytes" magic. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+void cb_data_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->data_event.valid_bytes == _ACC_DATA_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+void cb_launch_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+void cb_other_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+}
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_other_event, acc_reg);
+ reg_ (acc_ev_create, cb_data_event, acc_reg);
+ reg_ (acc_ev_delete, cb_data_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_data_event, acc_reg);
+ reg_ (acc_ev_free, cb_data_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_other_event, acc_reg);
+}
+
+/* Basic struct. */
+typedef struct A
+{
+ int a;
+ int b;
+#define VALID_BYTES_A \
+ _ACC_PROF_VALID_BYTES_STRUCT (A, b, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (int))
+} A;
+
+/* Add a "char" field. */
+typedef struct B
+{
+ int a;
+ int b;
+ char c;
+#define VALID_BYTES_B \
+ _ACC_PROF_VALID_BYTES_STRUCT (B, c, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} B;
+
+/* Add another "char" field. */
+typedef struct C
+{
+ int a;
+ int b;
+ char c, d;
+#define VALID_BYTES_C \
+ _ACC_PROF_VALID_BYTES_STRUCT (C, d, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} C;
+
+/* Add two "void *" fields. */
+typedef struct D
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+#define VALID_BYTES_D \
+ _ACC_PROF_VALID_BYTES_STRUCT (D, f, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} D;
+
+/* Add another three "char" fields. */
+typedef struct E
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+ char g, h, i;
+#define VALID_BYTES_E \
+ _ACC_PROF_VALID_BYTES_STRUCT (E, i, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} E;
+
+int main()
+{
+ A A1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof A1, VALID_BYTES_A);
+ assert (VALID_BYTES_A <= sizeof A1);
+ DEBUG_printf ("&A1=%p, &A1.b=%p\n", &A1, &A1.b);
+ assert (((char *) &A1) + VALID_BYTES_A == (char *) (&A1.b + 1));
+
+ B B1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof B1, VALID_BYTES_B);
+ assert (VALID_BYTES_B <= sizeof B1);
+ DEBUG_printf ("&B1=%p, &B1.c=%p\n", &B1, &B1.c);
+ assert (((char *) &B1) + VALID_BYTES_B == (char *) (&B1.c + 1));
+
+ assert (VALID_BYTES_B == VALID_BYTES_A + 1 * sizeof (char));
+
+ C C1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof C1, VALID_BYTES_C);
+ assert (VALID_BYTES_C <= sizeof C1);
+ DEBUG_printf ("&C1=%p, &C1.d=%p\n", &C1, &C1.d);
+ assert (((char *) &C1) + VALID_BYTES_C == (char *) (&C1.d + 1));
+
+ assert (VALID_BYTES_C == VALID_BYTES_B + 1 * sizeof (char));
+
+ D D1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof D1, VALID_BYTES_D);
+ assert (VALID_BYTES_D <= sizeof D1);
+ DEBUG_printf ("&D1=%p, &D1.f=%p\n", &D1, &D1.f);
+ assert (((char *) &D1) + VALID_BYTES_D == (char *) (&D1.f + 1));
+
+ assert (VALID_BYTES_D > VALID_BYTES_C);
+
+ E E1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof E1, VALID_BYTES_E);
+ assert (VALID_BYTES_E <= sizeof E1);
+ DEBUG_printf ("&E1=%p, &E1.i=%p\n", &E1, &E1.i);
+ assert (((char *) &E1) + VALID_BYTES_E == (char *) (&E1.i + 1));
+
+ assert (VALID_BYTES_E == VALID_BYTES_D + 3 * sizeof (char));
+
+#pragma acc parallel
+ {
+ }
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
new file mode 100644
index 0000000..11e3ad7
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
@@ -0,0 +1,55 @@
+/* Test "acc_prof_info"'s "version" field. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+void cb_any_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->version == 201711);
+}
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_any_event, acc_reg);
+ reg_ (acc_ev_create, cb_any_event, acc_reg);
+ reg_ (acc_ev_delete, cb_any_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_any_event, acc_reg);
+ reg_ (acc_ev_free, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_any_event, acc_reg);
+}
+
+int main()
+{
+#pragma acc parallel
+ {
+ }
+
+ return 0;
+}
--
2.8.1
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH, og9] Port OpenACC profiling interface to OG9
2019-06-17 13:28 ` Kwok Cheung Yeung
@ 2019-06-17 17:24 ` Thomas Schwinge
2019-06-24 19:37 ` Kwok Cheung Yeung
0 siblings, 1 reply; 23+ messages in thread
From: Thomas Schwinge @ 2019-06-17 17:24 UTC (permalink / raw)
To: Kwok Cheung Yeung; +Cc: Catherine Moore, gcc-patches
Hi Kwok!
On Mon, 17 Jun 2019 14:27:46 +0100, Kwok Cheung Yeung <kcy@codesourcery.com> wrote:
> This is a straightforward port of the OpenACC profiling interface from
> OG8 to OG9, with a few tweaks
Thanks for looking into this.
> to compensate for patches that have not
> been carried over to OG9.
Conceptually ACK. (I have not reviewed what's missing/got dropped.)
> I have also bundled in the profiling hooks and
> documentation updates that have been added since the original patch in OG8.
ACK.
> Okay to push to openacc-gcc-9-branch?
What you probably didn't know (sorry!) is that trunk r271346,
<http://mid.mail-archive.com/yxfplfz4anys.fsf@hertz.schwinge.homeip.net>,
contains some changes that are not in the og8 code: code and
documentation improvements, TODOs resolved, etc. It also doesn't contain
the actual 'acc_register_library' implementation, because that one needs
further work, as discussed before.
I think what would be best, is the following approach:
- First, backport trunk r271346 to og9.
That might not be completely trivial, because as you know, og9
contains a number of "feature" commits that need to include changes
related to the profiling code. It's the question in which order to
sequence patches -- whether these changes related to the profiling
code are part of the individual "feature" commits, or they're part of
a later "profiling" commit. As og9 has been published with "feature"
commits not containing any profiling bits, all these things will have
to be in a later "profiling" commit.
However, for upstreaming this into trunk later on, it will be
beneficial to have the backported "profiling" commit as similar as
possible to trunk r271346, so we shall live with some short-lived
inconsistencies, maybe even a few testuite regressions, which then
get resolved when you...
- Second, on top of that, add the pieces of functionality (from the
og8) version that are missing from the trunk r271346 backport. Of
course, remove all changes that would worsen the state, compared to
what trunk r271346 already contains.
So, conceptually: a first commit to backport trunk r271346, then a second
commit containing a merger of a (temporary) revert of the first commit
followed by applying the patch you just posted. Then, remove from the
second commit all changes that worsen the state, compared to what trunk
r271346 already contains.
Or, in other words: split the patch you just posted into two, where the
first one is as close as possible to a backport of trunk r271346, then
all other changes in a second commit.
Will that work?
I'll be happy to help review these changes, especially whether something
should be part of the second commit, or get dropped.
Grüße
Thomas
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH, og9] Port OpenACC profiling interface to OG9
2019-06-17 17:24 ` Thomas Schwinge
@ 2019-06-24 19:37 ` Kwok Cheung Yeung
2019-07-24 11:05 ` Thomas Schwinge
0 siblings, 1 reply; 23+ messages in thread
From: Kwok Cheung Yeung @ 2019-06-24 19:37 UTC (permalink / raw)
To: Thomas Schwinge; +Cc: Catherine Moore, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 2967 bytes --]
On 17/06/2019 6:24 pm, Thomas Schwinge wrote:
>> Okay to push to openacc-gcc-9-branch?
>
> What you probably didn't know (sorry!) is that trunk r271346,
> <http://mid.mail-archive.com/yxfplfz4anys.fsf@hertz.schwinge.homeip.net>,
> contains some changes that are not in the og8 code: code and
> documentation improvements, TODOs resolved, etc. It also doesn't contain
> the actual 'acc_register_library' implementation, because that one needs
> further work, as discussed before.
>
> I think what would be best, is the following approach:
>
> - First, backport trunk r271346 to og9.
>
> That might not be completely trivial, because as you know, og9
> contains a number of "feature" commits that need to include changes
> related to the profiling code. It's the question in which order to
> sequence patches -- whether these changes related to the profiling
> code are part of the individual "feature" commits, or they're part of
> a later "profiling" commit. As og9 has been published with "feature"
> commits not containing any profiling bits, all these things will have
> to be in a later "profiling" commit.
>
> However, for upstreaming this into trunk later on, it will be
> beneficial to have the backported "profiling" commit as similar as
> possible to trunk r271346, so we shall live with some short-lived
> inconsistencies, maybe even a few testuite regressions, which then
> get resolved when you...
>
> - Second, on top of that, add the pieces of functionality (from the
> og8) version that are missing from the trunk r271346 backport. Of
> course, remove all changes that would worsen the state, compared to
> what trunk r271346 already contains.
>
> So, conceptually: a first commit to backport trunk r271346, then a second
> commit containing a merger of a (temporary) revert of the first commit
> followed by applying the patch you just posted. Then, remove from the
> second commit all changes that worsen the state, compared to what trunk
> r271346 already contains.
>
> Or, in other words: split the patch you just posted into two, where the
> first one is as close as possible to a backport of trunk r271346, then
> all other changes in a second commit.
>
> Will that work?
>
I have now ported over the mainline patch over to OG9, plus an
additional patch on top of that to bring in the bits from OG8 that did
not make it upstream.
I have dropped the differences in comments, TODOs, documentation etc. in
favour of the upstream patch. There are also various places where the
OG8 patch sets up profiling, then gotos the end of the function to tear
it down again, whereas the mainline version just aborts early without
setting up profiling in the first place - these I have also resolved in
favour of the mainline version.
I have rerun the libgomp testsuite with no regressions noted.
Okay to push to openacc-gcc-9-branch?
Thanks
Kwok
[-- Attachment #2: 0001-OpenACC-Profiling-Interface-incomplete.patch --]
[-- Type: text/plain, Size: 175942 bytes --]
From ba24e40c9c1b8c20ed77ed408bffb07e237e23ba Mon Sep 17 00:00:00 2001
From: tschwinge <tschwinge@138bc75d-0d04-0410-961f-82ee72b054a4>
Date: Fri, 17 May 2019 19:13:36 +0000
Subject: [PATCH 1/2] OpenACC Profiling Interface (incomplete)
libgomp/
* acc_prof.h: New file.
* oacc-profiling.c: Likewise.
* Makefile.am (nodist_libsubinclude_HEADERS, libgomp_la_SOURCES):
Add these, respectively.
* Makefile.in: Regenerate.
* env.c (initialize_env): Call goacc_profiling_initialize.
* oacc-plugin.c (GOMP_PLUGIN_goacc_thread)
(GOMP_PLUGIN_goacc_profiling_dispatch): New functions.
* oacc-plugin.h (GOMP_PLUGIN_goacc_thread)
(GOMP_PLUGIN_goacc_profiling_dispatch): Declare.
* libgomp.map (OACC_2.5.1): Add acc_prof_lookup,
acc_prof_register, acc_prof_unregister, and acc_register_library.
(GOMP_PLUGIN_1.3): Add GOMP_PLUGIN_goacc_profiling_dispatch, and
GOMP_PLUGIN_goacc_thread.
* oacc-int.h (struct goacc_thread): Add prof_info, api_info,
prof_callbacks_enabled members.
(goacc_prof_enabled, goacc_profiling_initialize)
(_goacc_profiling_dispatch_p, _goacc_profiling_setup_p)
(goacc_profiling_dispatch): Declare.
(GOACC_PROF_ENABLED, GOACC_PROFILING_DISPATCH_P)
(GOACC_PROFILING_SETUP_P): Define.
* oacc-async.c (acc_async_test, acc_async_test_all, acc_wait)
(acc_wait_async, acc_wait_all, acc_wait_all_async): Update for
OpenACC Profiling Interface.
* oacc-cuda.c (acc_get_current_cuda_device)
(acc_get_current_cuda_context, acc_get_cuda_stream)
(acc_set_cuda_stream): Likewise.
* oacc-init.c (acc_init_1, goacc_attach_host_thread_to_device)
(acc_init, acc_set_device_type, acc_get_device_type)
(acc_get_device_num, goacc_lazy_initialize): Likewise.
* oacc-mem.c (acc_malloc, acc_free, memcpy_tofrom_device)
(acc_deviceptr, acc_hostptr, acc_is_present, acc_map_data)
(acc_unmap_data, present_create_copy, delete_copyout)
(update_dev_host): Likewise.
* oacc-parallel.c (GOACC_parallel_keyed, GOACC_data_start)
(GOACC_data_end, GOACC_enter_exit_data, GOACC_update, GOACC_wait):
Likewise.
* plugin/plugin-nvptx.c (nvptx_exec, nvptx_alloc, nvptx_free)
(GOMP_OFFLOAD_openacc_exec, GOMP_OFFLOAD_openacc_async_exec):
Likewise.
* libgomp.texi: Update.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c: New
file.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c: Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c:
Likewise.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@271346 138bc75d-0d04-0410-961f-82ee72b054a4
---
libgomp/ChangeLog.openacc | 55 ++
libgomp/Makefile.am | 4 +-
libgomp/Makefile.in | 7 +-
libgomp/acc_prof.h | 252 ++++++++
libgomp/env.c | 2 +
libgomp/libgomp.map | 16 +-
libgomp/libgomp.texi | 412 ++++++++++++
libgomp/oacc-async.c | 121 +++-
libgomp/oacc-cuda.c | 81 ++-
libgomp/oacc-init.c | 124 +++-
libgomp/oacc-int.h | 29 +
libgomp/oacc-mem.c | 113 +++-
libgomp/oacc-parallel.c | 457 ++++++++++++-
libgomp/oacc-plugin.c | 17 +
libgomp/oacc-plugin.h | 7 +
libgomp/oacc-profiling.c | 662 +++++++++++++++++++
libgomp/plugin/plugin-nvptx.c | 194 +++++-
.../acc_prof-dispatch-1.c | 353 ++++++++++
.../libgomp.oacc-c-c++-common/acc_prof-init-1.c | 316 +++++++++
.../libgomp.oacc-c-c++-common/acc_prof-kernels-1.c | 229 +++++++
.../acc_prof-parallel-1.c | 719 +++++++++++++++++++++
.../acc_prof-valid_bytes-1.c | 226 +++++++
.../libgomp.oacc-c-c++-common/acc_prof-version-1.c | 76 +++
23 files changed, 4401 insertions(+), 71 deletions(-)
create mode 100644 libgomp/acc_prof.h
create mode 100644 libgomp/oacc-profiling.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
diff --git a/libgomp/ChangeLog.openacc b/libgomp/ChangeLog.openacc
index b3bcb31..04c7778 100644
--- a/libgomp/ChangeLog.openacc
+++ b/libgomp/ChangeLog.openacc
@@ -1,3 +1,58 @@
+2019-05-17 Thomas Schwinge <thomas@codesourcery.com>
+
+ * acc_prof.h: New file.
+ * oacc-profiling.c: Likewise.
+ * Makefile.am (nodist_libsubinclude_HEADERS, libgomp_la_SOURCES):
+ Add these, respectively.
+ * Makefile.in: Regenerate.
+ * env.c (initialize_env): Call goacc_profiling_initialize.
+ * oacc-plugin.c (GOMP_PLUGIN_goacc_thread)
+ (GOMP_PLUGIN_goacc_profiling_dispatch): New functions.
+ * oacc-plugin.h (GOMP_PLUGIN_goacc_thread)
+ (GOMP_PLUGIN_goacc_profiling_dispatch): Declare.
+ * libgomp.map (OACC_2.5.1): Add acc_prof_lookup,
+ acc_prof_register, acc_prof_unregister, and acc_register_library.
+ (GOMP_PLUGIN_1.3): Add GOMP_PLUGIN_goacc_profiling_dispatch, and
+ GOMP_PLUGIN_goacc_thread.
+ * oacc-int.h (struct goacc_thread): Add prof_info, api_info,
+ prof_callbacks_enabled members.
+ (goacc_prof_enabled, goacc_profiling_initialize)
+ (_goacc_profiling_dispatch_p, _goacc_profiling_setup_p)
+ (goacc_profiling_dispatch): Declare.
+ (GOACC_PROF_ENABLED, GOACC_PROFILING_DISPATCH_P)
+ (GOACC_PROFILING_SETUP_P): Define.
+ * oacc-async.c (acc_async_test, acc_async_test_all, acc_wait)
+ (acc_wait_async, acc_wait_all, acc_wait_all_async): Update for
+ OpenACC Profiling Interface.
+ * oacc-cuda.c (acc_get_current_cuda_device)
+ (acc_get_current_cuda_context, acc_get_cuda_stream)
+ (acc_set_cuda_stream): Likewise.
+ * oacc-init.c (acc_init_1, goacc_attach_host_thread_to_device)
+ (acc_init, acc_set_device_type, acc_get_device_type)
+ (acc_get_device_num, goacc_lazy_initialize): Likewise.
+ * oacc-mem.c (acc_malloc, acc_free, memcpy_tofrom_device)
+ (acc_deviceptr, acc_hostptr, acc_is_present, acc_map_data)
+ (acc_unmap_data, present_create_copy, delete_copyout)
+ (update_dev_host): Likewise.
+ * oacc-parallel.c (GOACC_parallel_keyed, GOACC_data_start)
+ (GOACC_data_end, GOACC_enter_exit_data, GOACC_update, GOACC_wait):
+ Likewise.
+ * plugin/plugin-nvptx.c (nvptx_exec, nvptx_alloc, nvptx_free)
+ (GOMP_OFFLOAD_openacc_exec, GOMP_OFFLOAD_openacc_async_exec):
+ Likewise.
+ * libgomp.texi: Update.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c: New
+ file.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c: Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c:
+ Likewise.
+
2019-05-28 Julian Brown <julian@codesourcery.com>
* testsuite/libgomp.oacc-fortran/gangprivate-attrib-2.f90: New test.
diff --git a/libgomp/Makefile.am b/libgomp/Makefile.am
index 2db3865..5091870 100644
--- a/libgomp/Makefile.am
+++ b/libgomp/Makefile.am
@@ -72,7 +72,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c error.c \
proc.c sem.c bar.c ptrlock.c time.c fortran.c affinity.c target.c \
splay-tree.c libgomp-plugin.c oacc-parallel.c oacc-host.c oacc-init.c \
oacc-mem.c oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
- affinity-fmt.c teams.c
+ affinity-fmt.c teams.c oacc-profiling.c
include $(top_srcdir)/plugin/Makefrag.am
@@ -81,7 +81,7 @@ libgomp_la_SOURCES += openacc.f90
endif
nodist_noinst_HEADERS = libgomp_f.h
-nodist_libsubinclude_HEADERS = omp.h openacc.h
+nodist_libsubinclude_HEADERS = omp.h openacc.h acc_prof.h
if USE_FORTRAN
nodist_finclude_HEADERS = omp_lib.h omp_lib.f90 omp_lib.mod omp_lib_kinds.mod \
openacc_lib.h openacc.f90 openacc.mod openacc_kinds.mod
diff --git a/libgomp/Makefile.in b/libgomp/Makefile.in
index 820a576..23efc84 100644
--- a/libgomp/Makefile.in
+++ b/libgomp/Makefile.in
@@ -216,7 +216,7 @@ am_libgomp_la_OBJECTS = alloc.lo atomic.lo barrier.lo critical.lo \
target.lo splay-tree.lo libgomp-plugin.lo oacc-parallel.lo \
oacc-host.lo oacc-init.lo oacc-mem.lo oacc-async.lo \
oacc-plugin.lo oacc-cuda.lo priority_queue.lo affinity-fmt.lo \
- teams.lo $(am__objects_1)
+ teams.lo oacc-profiling.lo $(am__objects_1)
libgomp_la_OBJECTS = $(am_libgomp_la_OBJECTS)
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
@@ -553,7 +553,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c \
affinity.c target.c splay-tree.c libgomp-plugin.c \
oacc-parallel.c oacc-host.c oacc-init.c oacc-mem.c \
oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
- affinity-fmt.c teams.c $(am__append_3)
+ affinity-fmt.c teams.c oacc-profiling.c $(am__append_3)
# Nvidia PTX OpenACC plugin.
@PLUGIN_NVPTX_TRUE@libgomp_plugin_nvptx_version_info = -version-info $(libtool_VERSION)
@@ -577,7 +577,7 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c \
@PLUGIN_HSA_TRUE@libgomp_plugin_hsa_la_LIBADD = libgomp.la $(PLUGIN_HSA_LIBS)
@PLUGIN_HSA_TRUE@libgomp_plugin_hsa_la_LIBTOOLFLAGS = --tag=disable-static
nodist_noinst_HEADERS = libgomp_f.h
-nodist_libsubinclude_HEADERS = omp.h openacc.h
+nodist_libsubinclude_HEADERS = omp.h openacc.h acc_prof.h
@USE_FORTRAN_TRUE@nodist_finclude_HEADERS = omp_lib.h omp_lib.f90 omp_lib.mod omp_lib_kinds.mod \
@USE_FORTRAN_TRUE@ openacc_lib.h openacc.f90 openacc.mod openacc_kinds.mod
@@ -755,6 +755,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-mem.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-parallel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-plugin.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-profiling.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ordered.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/parallel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/priority_queue.Plo@am__quote@
diff --git a/libgomp/acc_prof.h b/libgomp/acc_prof.h
new file mode 100644
index 0000000..c7a2197
--- /dev/null
+++ b/libgomp/acc_prof.h
@@ -0,0 +1,252 @@
+/* OpenACC Profiling Interface
+
+ Copyright (C) 2019 Free Software Foundation, Inc.
+
+ Contributed by Mentor, a Siemens Business.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+#ifndef _ACC_PROF_H
+#define _ACC_PROF_H 1
+
+
+/* The OpenACC specification doesn't say so explicitly, but as its Profiling
+ Interface explicitly makes use of, for example, <openacc.h>'s
+ 'acc_device_t', we supposedly are to '#include' that file here. */
+
+#include <openacc.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Events. */
+
+typedef enum acc_event_t
+{
+ acc_ev_none = 0,
+ acc_ev_device_init_start,
+ acc_ev_device_init_end,
+ acc_ev_device_shutdown_start,
+ acc_ev_device_shutdown_end,
+ acc_ev_runtime_shutdown,
+ acc_ev_create,
+ acc_ev_delete,
+ acc_ev_alloc,
+ acc_ev_free,
+ acc_ev_enter_data_start,
+ acc_ev_enter_data_end,
+ acc_ev_exit_data_start,
+ acc_ev_exit_data_end,
+ acc_ev_update_start,
+ acc_ev_update_end,
+ acc_ev_compute_construct_start,
+ acc_ev_compute_construct_end,
+ acc_ev_enqueue_launch_start,
+ acc_ev_enqueue_launch_end,
+ acc_ev_enqueue_upload_start,
+ acc_ev_enqueue_upload_end,
+ acc_ev_enqueue_download_start,
+ acc_ev_enqueue_download_end,
+ acc_ev_wait_start,
+ acc_ev_wait_end,
+ acc_ev_last
+} acc_event_t;
+
+
+/* Callbacks Signature. */
+
+/* "The datatype 'ssize_t' means a signed 32-bit integer for a 32-bit binary
+ and a 64-bit integer for a 64-bit binary". */
+typedef signed long int _acc_prof_ssize_t;
+/* "The datatype 'size_t' means an unsigned 32-bit integer for a 32-bit binary
+ and a 64-bit integer for a 64-bit binary". */
+typedef unsigned long int _acc_prof_size_t;
+/* "The datatype 'int' means a 32-bit integer for both 32-bit and 64-bit
+ binaries". */
+typedef int _acc_prof_int_t;
+
+/* Internal helpers: a struct's 'valid_bytes' may be less than its 'sizeof'. */
+#define _ACC_PROF_VALID_BYTES_STRUCT(_struct, _lastfield, _valid_bytes_lastfield) \
+ offsetof (_struct, _lastfield) + (_valid_bytes_lastfield)
+#if 0 /* Untested. */
+#define _ACC_PROF_VALID_BYTES_TYPE_N(_type, _n, _valid_bytes_type) \
+ ((_n - 1) * sizeof (_type) + (_valid_bytes_type))
+#endif
+#define _ACC_PROF_VALID_BYTES_BASICTYPE(_basictype) \
+ (sizeof (_basictype))
+
+typedef struct acc_prof_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ _acc_prof_int_t version;
+ acc_device_t device_type;
+ _acc_prof_int_t device_number;
+ _acc_prof_int_t thread_id;
+ _acc_prof_ssize_t async;
+ _acc_prof_ssize_t async_queue;
+ const char *src_file;
+ const char *func_name;
+ _acc_prof_int_t line_no, end_line_no;
+ _acc_prof_int_t func_line_no, func_end_line_no;
+#define _ACC_PROF_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_prof_info, func_end_line_no, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_int_t))
+} acc_prof_info;
+
+/* We implement the OpenACC 2.6 Profiling Interface. */
+
+#define _ACC_PROF_INFO_VERSION 201711
+
+typedef enum acc_construct_t
+{
+ acc_construct_parallel = 0,
+ acc_construct_kernels,
+ acc_construct_loop,
+ acc_construct_data,
+ acc_construct_enter_data,
+ acc_construct_exit_data,
+ acc_construct_host_data,
+ acc_construct_atomic,
+ acc_construct_declare,
+ acc_construct_init,
+ acc_construct_shutdown,
+ acc_construct_set,
+ acc_construct_update,
+ acc_construct_routine,
+ acc_construct_wait,
+ acc_construct_runtime_api,
+ acc_construct_serial
+} acc_construct_t;
+
+typedef struct acc_data_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ const char *var_name;
+ _acc_prof_size_t bytes;
+ const void *host_ptr;
+ const void *device_ptr;
+#define _ACC_DATA_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_data_event_info, device_ptr, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_data_event_info;
+
+typedef struct acc_launch_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+ const char *kernel_name;
+ _acc_prof_size_t num_gangs, num_workers, vector_length;
+#define _ACC_LAUNCH_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_launch_event_info, vector_length, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_size_t))
+} acc_launch_event_info;
+
+typedef struct acc_other_event_info
+{
+ acc_event_t event_type;
+ _acc_prof_int_t valid_bytes;
+ acc_construct_t parent_construct;
+ _acc_prof_int_t implicit;
+ void *tool_info;
+#define _ACC_OTHER_EVENT_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_other_event_info, tool_info, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_other_event_info;
+
+typedef union acc_event_info
+{
+ acc_event_t event_type;
+ acc_data_event_info data_event;
+ acc_launch_event_info launch_event;
+ acc_other_event_info other_event;
+} acc_event_info;
+
+typedef enum acc_device_api
+{
+ acc_device_api_none = 0,
+ acc_device_api_cuda,
+ acc_device_api_opencl,
+ acc_device_api_coi,
+ acc_device_api_other
+} acc_device_api;
+
+typedef struct acc_api_info
+{
+ acc_device_api device_api;
+ _acc_prof_int_t valid_bytes;
+ acc_device_t device_type;
+ _acc_prof_int_t vendor;
+ const void *device_handle;
+ const void *context_handle;
+ const void *async_handle;
+#define _ACC_API_INFO_VALID_BYTES \
+ _ACC_PROF_VALID_BYTES_STRUCT (acc_api_info, async_handle, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} acc_api_info;
+
+/* Don't tag 'acc_prof_callback' as '__GOACC_NOTHROW': these functions are
+ provided by user code, and must be expected to do anything. */
+typedef void (*acc_prof_callback) (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+
+
+/* Loading the Library. */
+
+typedef enum acc_register_t
+{
+ acc_reg = 0,
+ acc_toggle = 1,
+ acc_toggle_per_thread = 2
+} acc_register_t;
+
+typedef void (*acc_prof_reg) (acc_event_t, acc_prof_callback, acc_register_t);
+extern void acc_prof_register (acc_event_t, acc_prof_callback,
+ acc_register_t) __GOACC_NOTHROW;
+extern void acc_prof_unregister (acc_event_t, acc_prof_callback,
+ acc_register_t) __GOACC_NOTHROW;
+typedef void (*acc_query_fn) ();
+typedef acc_query_fn (*acc_prof_lookup_func) (const char *);
+extern acc_query_fn acc_prof_lookup (const char *) __GOACC_NOTHROW;
+/* Don't tag 'acc_register_library' as '__GOACC_NOTHROW': this function can be
+ overridden by user code, and must be expected to do anything. */
+extern void acc_register_library (acc_prof_reg, acc_prof_reg,
+ acc_prof_lookup_func);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* _ACC_PROF_H */
diff --git a/libgomp/env.c b/libgomp/env.c
index 7937fbb..29d9f58 100644
--- a/libgomp/env.c
+++ b/libgomp/env.c
@@ -1425,5 +1425,7 @@ initialize_env (void)
parse_gomp_openacc_dim ();
goacc_runtime_initialize ();
+
+ goacc_profiling_initialize ();
}
#endif /* LIBGOMP_OFFLOADED_ONLY */
diff --git a/libgomp/libgomp.map b/libgomp/libgomp.map
index 717ae66..3be4a0c 100644
--- a/libgomp/libgomp.map
+++ b/libgomp/libgomp.map
@@ -476,6 +476,14 @@ OACC_2.5 {
acc_update_self_async_array_h_;
} OACC_2.0.1;
+OACC_2.5.1 {
+ global:
+ acc_prof_lookup;
+ acc_prof_register;
+ acc_prof_unregister;
+ acc_register_library;
+} OACC_2.5;
+
OACC_2.6 {
global:
acc_get_property;
@@ -488,7 +496,7 @@ OACC_2.6 {
acc_detach_async;
acc_detach_finalize;
acc_detach_finalize_async;
-} OACC_2.5;
+} OACC_2.5.1;
GOACC_2.0 {
global:
@@ -536,3 +544,9 @@ GOMP_PLUGIN_1.2 {
global:
GOMP_PLUGIN_acc_default_dim;
} GOMP_PLUGIN_1.1;
+
+GOMP_PLUGIN_1.3 {
+ global:
+ GOMP_PLUGIN_goacc_profiling_dispatch;
+ GOMP_PLUGIN_goacc_thread;
+} GOMP_PLUGIN_1.2;
diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi
index 7538846..2e05272 100644
--- a/libgomp/libgomp.texi
+++ b/libgomp/libgomp.texi
@@ -111,6 +111,7 @@ changed to GNU Offloading and Multi Processing Runtime Library.
asynchronous operations.
* OpenACC Library Interoperability:: OpenACC library interoperability with the
NVIDIA CUBLAS library.
+* OpenACC Profiling Interface::
* The libgomp ABI:: Notes on the external ABI presented by libgomp.
* Reporting Bugs:: How to report bugs in the GNU Offloading and
Multi Processing Runtime Library.
@@ -1901,6 +1902,13 @@ API routines for target platforms.
* acc_get_current_cuda_context::Get CUDA context handle.
* acc_get_cuda_stream:: Get CUDA stream handle.
* acc_set_cuda_stream:: Set CUDA stream handle.
+
+API routines for the OpenACC Profiling Interface.
+
+* acc_prof_register:: Register callbacks.
+* acc_prof_unregister:: Unregister callbacks.
+* acc_prof_lookup:: Obtain inquiry functions.
+* acc_register_library:: Library registration.
@end menu
@@ -2865,6 +2873,90 @@ A.2.1.4.
+@node acc_prof_register
+@section @code{acc_prof_register} -- Register callbacks.
+@table @asis
+@item @emph{Description}:
+This function registers callbacks.
+
+@item @emph{C/C++}:
+@multitable @columnfractions .20 .80
+@item @emph{Prototype}: @tab @code{void acc_prof_register (acc_event_t, acc_prof_callback, acc_register_t);}
+@end multitable
+
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+5.3.
+@end table
+
+
+
+@node acc_prof_unregister
+@section @code{acc_prof_unregister} -- Unregister callbacks.
+@table @asis
+@item @emph{Description}:
+This function unregisters callbacks.
+
+@item @emph{C/C++}:
+@multitable @columnfractions .20 .80
+@item @emph{Prototype}: @tab @code{void acc_prof_unregister (acc_event_t, acc_prof_callback, acc_register_t);}
+@end multitable
+
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+5.3.
+@end table
+
+
+
+@node acc_prof_lookup
+@section @code{acc_prof_lookup} -- Obtain inquiry functions.
+@table @asis
+@item @emph{Description}:
+Function to obtain inquiry functions.
+
+@item @emph{C/C++}:
+@multitable @columnfractions .20 .80
+@item @emph{Prototype}: @tab @code{acc_query_fn acc_prof_lookup (const char *);}
+@end multitable
+
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+5.3.
+@end table
+
+
+
+@node acc_register_library
+@section @code{acc_register_library} -- Library registration.
+@table @asis
+@item @emph{Description}:
+Function for library registration.
+
+@item @emph{C/C++}:
+@multitable @columnfractions .20 .80
+@item @emph{Prototype}: @tab @code{void acc_register_library (acc_prof_reg, acc_prof_reg, acc_prof_lookup_func);}
+@end multitable
+
+@item @emph{See also}:
+@ref{OpenACC Profiling Interface}, @ref{ACC_PROFLIB}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+5.3.
+@end table
+
+
+
@c ---------------------------------------------------------------------
@c OpenACC Environment Variables
@c ---------------------------------------------------------------------
@@ -2874,11 +2966,14 @@ A.2.1.4.
The variables @env{ACC_DEVICE_TYPE} and @env{ACC_DEVICE_NUM}
are defined by section 4 of the OpenACC specification in version 2.6.
+The variable @env{ACC_PROFLIB}
+is defined by section 4 of the OpenACC specification in version 2.6.
The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
@menu
* ACC_DEVICE_TYPE::
* ACC_DEVICE_NUM::
+* ACC_PROFLIB::
* GCC_ACC_NOTIFY::
@end menu
@@ -2904,6 +2999,19 @@ The variable @env{GCC_ACC_NOTIFY} is used for diagnostic purposes.
+@node ACC_PROFLIB
+@section @code{ACC_PROFLIB}
+@table @asis
+@item @emph{See also}:
+@ref{acc_register_library}, @ref{OpenACC Profiling Interface}
+
+@item @emph{Reference}:
+@uref{https://www.openacc.org, OpenACC specification v2.6}, section
+4.3.
+@end table
+
+
+
@node GCC_ACC_NOTIFY
@section @code{GCC_ACC_NOTIFY}
@table @asis
@@ -3120,6 +3228,310 @@ Application Programming Interface”, Version 2.6.}
@c ---------------------------------------------------------------------
+@c OpenACC Profiling Interface
+@c ---------------------------------------------------------------------
+
+@node OpenACC Profiling Interface
+@chapter OpenACC Profiling Interface
+
+@section Implementation Status and Implementation-Defined Behavior
+
+We're implementing the OpenACC Profiling Interface as defined by the
+OpenACC 2.6 specification. We're clarifying some aspects here as
+@emph{implementation-defined behavior}, while they're still under
+discussion within the OpenACC Technical Committee.
+
+This implementation is tuned to keep the performance impact as low as
+possible for the (very common) case that the Profiling Interface is
+not enabled. This is relevant, as the Profiling Interface affects all
+the @emph{hot} code paths (in the target code, not in the offloaded
+code). Users of the OpenACC Profiling Interface can be expected to
+understand that performance will be impacted to some degree once the
+Profiling Interface has gotten enabled: for example, because of the
+@emph{runtime} (libgomp) calling into a third-party @emph{library} for
+every event that has been registered.
+
+We're not yet accounting for the fact that @cite{OpenACC events may
+occur during event processing}.
+
+We're not yet implementing initialization via a
+@code{acc_register_library} function that is either statically linked
+in, or dynamically via @env{LD_PRELOAD}.
+Initialization via @code{acc_register_library} functions dynamically
+loaded via the @env{ACC_PROFLIB} environment variable does work, as
+does directly calling @code{acc_prof_register},
+@code{acc_prof_unregister}, @code{acc_prof_lookup}.
+
+As currently there are no inquiry functions defined, calls to
+@code{acc_prof_lookup} will always return @code{NULL}.
+
+There aren't separate @emph{start}, @emph{stop} events defined for the
+event types @code{acc_ev_create}, @code{acc_ev_delete},
+@code{acc_ev_alloc}, @code{acc_ev_free}. It's not clear if these
+should be triggered before or after the actual device-specific call is
+made. We trigger them after.
+
+Remarks about data provided to callbacks:
+
+@table @asis
+
+@item @code{acc_prof_info.event_type}
+It's not clear if for @emph{nested} event callbacks (for example,
+@code{acc_ev_enqueue_launch_start} as part of a parent compute
+construct), this should be set for the nested event
+(@code{acc_ev_enqueue_launch_start}), or if the value of the parent
+construct should remain (@code{acc_ev_compute_construct_start}). In
+this implementation, the value will generally correspond to the
+innermost nested event type.
+
+@item @code{acc_prof_info.device_type}
+@itemize
+
+@item
+For @code{acc_ev_compute_construct_start}, and in presence of an
+@code{if} clause with @emph{false} argument, this will still refer to
+the offloading device type.
+It's not clear if that's the expected behavior.
+
+@item
+Complementary to the item before, for
+@code{acc_ev_compute_construct_end}, this is set to
+@code{acc_device_host} in presence of an @code{if} clause with
+@emph{false} argument.
+It's not clear if that's the expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.thread_id}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.async}
+@itemize
+
+@item
+Not yet implemented correctly for
+@code{acc_ev_compute_construct_start}.
+
+@item
+In a compute construct, for host-fallback
+execution/@code{acc_device_host} it will always be
+@code{acc_async_sync}.
+It's not clear if that's the expected behavior.
+
+@item
+For @code{acc_ev_device_init_start} and @code{acc_ev_device_init_end},
+it will always be @code{acc_async_sync}.
+It's not clear if that's the expected behavior.
+
+@end itemize
+
+@item @code{acc_prof_info.async_queue}
+There is no @cite{limited number of asynchronous queues} in libgomp.
+This will always have the same value as @code{acc_prof_info.async}.
+
+@item @code{acc_prof_info.src_file}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_prof_info.func_name}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_prof_info.line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_prof_info.func_end_line_no}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_event_info.event_type}, @code{acc_event_info.*.event_type}
+Relating to @code{acc_prof_info.event_type} discussed above, in this
+implementation, this will always be the same value as
+@code{acc_prof_info.event_type}.
+
+@item @code{acc_event_info.*.parent_construct}
+@itemize
+
+@item
+Will be @code{acc_construct_parallel} for all OpenACC compute
+constructs as well as many OpenACC Runtime API calls; should be the
+one matching the actual construct, or
+@code{acc_construct_runtime_api}, respectively.
+
+@item
+Will be @code{acc_construct_enter_data} or
+@code{acc_construct_exit_data} when processing variable mappings
+specified in OpenACC @emph{declare} directives; should be
+@code{acc_construct_declare}.
+
+@item
+For implicit @code{acc_ev_device_init_start},
+@code{acc_ev_device_init_end}, and explicit as well as implicit
+@code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start}, and
+@code{acc_ev_enqueue_download_end}, will be
+@code{acc_construct_parallel}; should reflect the real parent
+construct.
+
+@end itemize
+
+@item @code{acc_event_info.*.implicit}
+For @code{acc_ev_alloc}, @code{acc_ev_free},
+@code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end},
+@code{acc_ev_enqueue_download_start}, and
+@code{acc_ev_enqueue_download_end}, this currently will be @code{1}
+also for explicit usage.
+
+@item @code{acc_event_info.data_event.var_name}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_event_info.data_event.host_ptr}
+For @code{acc_ev_alloc}, and @code{acc_ev_free}, this is always
+@code{NULL}.
+
+@item @code{typedef union acc_api_info}
+@dots{} as printed in @cite{5.2.3. Third Argument: API-Specific
+Information}. This should obviously be @code{typedef @emph{struct}
+acc_api_info}.
+
+@item @code{acc_api_info.device_api}
+Possibly not yet implemented correctly for
+@code{acc_ev_compute_construct_start},
+@code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}:
+will always be @code{acc_device_api_none} for these event types.
+For @code{acc_ev_enter_data_start}, it will be
+@code{acc_device_api_none} in some cases.
+
+@item @code{acc_api_info.device_type}
+Always the same as @code{acc_prof_info.device_type}.
+
+@item @code{acc_api_info.vendor}
+Always @code{-1}; not yet implemented.
+
+@item @code{acc_api_info.device_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.context_handle}
+Always @code{NULL}; not yet implemented.
+
+@item @code{acc_api_info.async_handle}
+Always @code{NULL}; not yet implemented.
+
+@end table
+
+Remarks about certain event types:
+
+@table @asis
+
+@item @code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}
+@itemize
+
+@item
+@c See 'DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT' in
+@c 'libgomp.oacc-c-c++-common/acc_prof-kernels-1.c',
+@c 'libgomp.oacc-c-c++-common/acc_prof-parallel-1.c'.
+Whan a compute construct triggers implicit
+@code{acc_ev_device_init_start} and @code{acc_ev_device_init_end}
+events, they currently aren't @emph{nested within} the corresponding
+@code{acc_ev_compute_construct_start} and
+@code{acc_ev_compute_construct_end}, but they're currently observed
+@emph{before} @code{acc_ev_compute_construct_start}.
+It's not clear what to do: the standard asks us provide a lot of
+details to the @code{acc_ev_compute_construct_start} callback, without
+(implicitly) initializing a device before?
+
+@item
+Callbacks for these event types will not be invoked for calls to the
+@code{acc_set_device_type} and @code{acc_set_device_num} functions.
+It's not clear if they should be.
+
+@end itemize
+
+@item @code{acc_ev_enter_data_start}, @code{acc_ev_enter_data_end}, @code{acc_ev_exit_data_start}, @code{acc_ev_exit_data_end}
+@itemize
+
+@item
+Callbacks for these event types will also be invoked for OpenACC
+@emph{host_data} constructs.
+It's not clear if they should be.
+
+@item
+Callbacks for these event types will also be invoked when processing
+variable mappings specified in OpenACC @emph{declare} directives.
+It's not clear if they should be.
+
+@end itemize
+
+@end table
+
+Callbacks for the following event types will be invoked, but dispatch
+and information provided therein has not yet been thoroughly reviewed:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@item @code{acc_ev_update_start}, @code{acc_ev_update_end}
+@item @code{acc_ev_enqueue_upload_start}, @code{acc_ev_enqueue_upload_end}
+@item @code{acc_ev_enqueue_download_start}, @code{acc_ev_enqueue_download_end}
+@end itemize
+
+During device initialization, and finalization, respectively,
+callbacks for the following event types will not yet be invoked:
+
+@itemize
+@item @code{acc_ev_alloc}
+@item @code{acc_ev_free}
+@end itemize
+
+Callbacks for the following event types have not yet been implemented,
+so currently won't be invoked:
+
+@itemize
+@item @code{acc_ev_device_shutdown_start}, @code{acc_ev_device_shutdown_end}
+@item @code{acc_ev_runtime_shutdown}
+@item @code{acc_ev_create}, @code{acc_ev_delete}
+@item @code{acc_ev_wait_start}, @code{acc_ev_wait_end}
+@end itemize
+
+For the following runtime library functions, not all expected
+callbacks will be invoked (mostly concerning implicit device
+initialization):
+
+@itemize
+@item @code{acc_get_num_devices}
+@item @code{acc_set_device_type}
+@item @code{acc_get_device_type}
+@item @code{acc_set_device_num}
+@item @code{acc_get_device_num}
+@item @code{acc_init}
+@item @code{acc_shutdown}
+@end itemize
+
+Aside from implicit device initialization, for the following runtime
+library functions, no callbacks will be invoked for shared-memory
+offloading devices (it's not clear if they should be):
+
+@itemize
+@item @code{acc_malloc}
+@item @code{acc_free}
+@item @code{acc_copyin}, @code{acc_present_or_copyin}, @code{acc_copyin_async}
+@item @code{acc_create}, @code{acc_present_or_create}, @code{acc_create_async}
+@item @code{acc_copyout}, @code{acc_copyout_async}, @code{acc_copyout_finalize}, @code{acc_copyout_finalize_async}
+@item @code{acc_delete}, @code{acc_delete_async}, @code{acc_delete_finalize}, @code{acc_delete_finalize_async}
+@item @code{acc_update_device}, @code{acc_update_device_async}
+@item @code{acc_update_self}, @code{acc_update_self_async}
+@item @code{acc_map_data}, @code{acc_unmap_data}
+@item @code{acc_memcpy_to_device}, @code{acc_memcpy_to_device_async}
+@item @code{acc_memcpy_from_device}, @code{acc_memcpy_from_device_async}
+@end itemize
+
+
+
+@c ---------------------------------------------------------------------
@c The libgomp ABI
@c ---------------------------------------------------------------------
diff --git a/libgomp/oacc-async.c b/libgomp/oacc-async.c
index 51bb676..1760e8c 100644
--- a/libgomp/oacc-async.c
+++ b/libgomp/oacc-async.c
@@ -43,17 +43,6 @@ get_goacc_thread (void)
return thr;
}
-static struct gomp_device_descr *
-get_goacc_thread_device (void)
-{
- struct goacc_thread *thr = goacc_thread ();
-
- if (!thr || !thr->dev)
- gomp_fatal ("no device active");
-
- return thr->dev;
-}
-
static int
validate_async_val (int async)
{
@@ -76,7 +65,10 @@ validate_async_val (int async)
/* Return the asyncqueue to be used for OpenACC async-argument ASYNC. This
might return NULL if no asyncqueue is to be used. Otherwise, if CREATE,
- create the asyncqueue if it doesn't exist yet. */
+ create the asyncqueue if it doesn't exist yet.
+
+ Unless CREATE, this will not generate any OpenACC Profiling Interface
+ events. */
attribute_hidden struct goacc_asyncqueue *
lookup_goacc_asyncqueue (struct goacc_thread *thr, bool create, int async)
@@ -152,8 +144,25 @@ acc_async_test (int async)
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
if (!aq)
return 1;
- else
- return thr->dev->openacc.async.test_func (aq);
+
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
+ int res = thr->dev->openacc.async.test_func (aq);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return res;
}
int
@@ -161,6 +170,10 @@ acc_async_test_all (void)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
int ret = 1;
gomp_mutex_lock (&thr->dev->openacc.async.lock);
for (goacc_aq_list l = thr->dev->openacc.async.active; l; l = l->next)
@@ -170,6 +183,13 @@ acc_async_test_all (void)
break;
}
gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return ret;
}
@@ -179,8 +199,26 @@ acc_wait (int async)
struct goacc_thread *thr = get_goacc_thread ();
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
- if (aq && !thr->dev->openacc.async.synchronize_func (aq))
+ if (!aq)
+ return;
+
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
+ if (!thr->dev->openacc.async.synchronize_func (aq))
gomp_fatal ("wait on %d failed", async);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
/* acc_async_wait is an OpenACC 1.0 compatibility name for acc_wait. */
@@ -205,10 +243,19 @@ acc_wait_async (int async1, int async2)
if (!aq1)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async2;
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq2 = lookup_goacc_asyncqueue (thr, true, async2);
/* An async queue is always synchronized with itself. */
if (aq1 == aq2)
- return;
+ goto out_prof;
if (aq2)
{
@@ -222,18 +269,35 @@ acc_wait_async (int async1, int async2)
if (!thr->dev->openacc.async.synchronize_func (aq1))
gomp_fatal ("wait on %d failed", async1);
}
+
+ out_prof:
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
acc_wait_all (void)
{
- struct gomp_device_descr *dev = get_goacc_thread_device ();
+ struct goacc_thread *thr = goacc_thread ();
+
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
bool ret = true;
- gomp_mutex_lock (&dev->openacc.async.lock);
- for (goacc_aq_list l = dev->openacc.async.active; l; l = l->next)
- ret &= dev->openacc.async.synchronize_func (l->aq);
- gomp_mutex_unlock (&dev->openacc.async.lock);
+ gomp_mutex_lock (&thr->dev->openacc.async.lock);
+ for (goacc_aq_list l = thr->dev->openacc.async.active; l; l = l->next)
+ ret &= thr->dev->openacc.async.synchronize_func (l->aq);
+ gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
if (!ret)
gomp_fatal ("wait all failed");
@@ -255,6 +319,15 @@ acc_wait_all_async (int async)
{
struct goacc_thread *thr = get_goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq waiting_queue = lookup_goacc_asyncqueue (thr, true, async);
bool ret = true;
@@ -270,6 +343,12 @@ acc_wait_all_async (int async)
}
gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
if (!ret)
gomp_fatal ("wait all async(%d) failed", async);
}
diff --git a/libgomp/oacc-cuda.c b/libgomp/oacc-cuda.c
index 1ca7149..2eda381 100644
--- a/libgomp/oacc-cuda.c
+++ b/libgomp/oacc-cuda.c
@@ -37,10 +37,23 @@ acc_get_current_cuda_device (void)
{
struct goacc_thread *thr = goacc_thread ();
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_device_func)
- return thr->dev->openacc.cuda.get_current_device_func ();
+ {
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
+ ret = thr->dev->openacc.cuda.get_current_device_func ();
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+ }
- return NULL;
+ return ret;
}
void *
@@ -48,10 +61,23 @@ acc_get_current_cuda_context (void)
{
struct goacc_thread *thr = goacc_thread ();
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_current_context_func)
- return thr->dev->openacc.cuda.get_current_context_func ();
-
- return NULL;
+ {
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
+ ret = thr->dev->openacc.cuda.get_current_context_func ();
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+ }
+
+ return ret;
}
void *
@@ -62,14 +88,32 @@ acc_get_cuda_stream (int async)
if (!async_valid_p (async))
return NULL;
+ void *ret = NULL;
if (thr && thr->dev && thr->dev->openacc.cuda.get_stream_func)
{
goacc_aq aq = lookup_goacc_asyncqueue (thr, false, async);
- if (aq)
- return thr->dev->openacc.cuda.get_stream_func (aq);
+ if (!aq)
+ return ret;
+
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
+ ret = thr->dev->openacc.cuda.get_stream_func (aq);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
-
- return NULL;
+
+ return ret;
}
/* As of OpenACC 2.6, the return code of this function appears to be
@@ -90,6 +134,15 @@ acc_set_cuda_stream (int async, void *stream)
int ret = 0;
if (thr && thr->dev && thr->dev->openacc.cuda.set_stream_func)
{
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq = get_goacc_asyncqueue (async);
/* Due to not using an asyncqueue for "acc_async_sync", this cannot be
used to change the CUDA stream associated with "acc_async_sync". */
@@ -98,11 +151,19 @@ acc_set_cuda_stream (int async, void *stream)
assert (async == acc_async_sync);
gomp_debug (0, "Refusing request to set CUDA stream associated"
" with \"acc_async_sync\"\n");
- return 0;
+ ret = 0;
+ goto out_prof;
}
gomp_mutex_lock (&thr->dev->openacc.async.lock);
ret = thr->dev->openacc.cuda.set_stream_func (aq, stream);
gomp_mutex_unlock (&thr->dev->openacc.async.lock);
+
+ out_prof:
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
return ret;
diff --git a/libgomp/oacc-init.c b/libgomp/oacc-init.c
index 0cd673e..f7ea58f 100644
--- a/libgomp/oacc-init.c
+++ b/libgomp/oacc-init.c
@@ -228,8 +228,67 @@ acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)
held before calling this function. */
static struct gomp_device_descr *
-acc_init_1 (acc_device_t d)
+acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
{
+ bool check_not_nested_p;
+ if (implicit)
+ {
+ /* In the implicit case, there should (TODO: must?) already be something
+ have been set up for an outer construct. */
+ check_not_nested_p = false;
+ }
+ else
+ {
+ check_not_nested_p = true;
+ /* TODO: should we set 'thr->prof_info' etc. in this case ('acc_init')?
+ The problem is, that we don't have 'thr' yet? (So,
+ 'check_not_nested_p = true' also is pointless actually.) */
+ }
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (check_not_nested_p);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_device_init_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = d;
+ prof_info.device_number = goacc_device_num;
+ prof_info.thread_id = -1;
+ prof_info.async = acc_async_sync;
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info device_init_event_info;
+ if (profiling_p)
+ {
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ device_init_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ device_init_event_info.other_event.parent_construct = parent_construct;
+ device_init_event_info.other_event.implicit = implicit;
+ device_init_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info, &api_info);
+
struct gomp_device_descr *base_dev, *acc_dev;
int ndevs;
@@ -261,6 +320,14 @@ acc_init_1 (acc_device_t d)
acc_init_state = initialized;
gomp_mutex_unlock (&acc_init_state_lock);
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_device_init_end;
+ device_init_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &device_init_event_info,
+ &api_info);
+ }
+
return base_dev;
}
@@ -454,7 +521,11 @@ goacc_attach_host_thread_to_device (int ord)
thr->dev = acc_dev = &base_dev[ord];
thr->saved_bound_dev = NULL;
thr->mapped_data = NULL;
-
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ /* Initially, all callbacks for all events are enabled. */
+ thr->prof_callbacks_enabled = true;
+
thr->target_tls
= acc_dev->openacc.create_thread_data_func (ord);
}
@@ -468,9 +539,7 @@ acc_init (acc_device_t d)
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
-
- cached_base_dev = acc_init_1 (d);
-
+ cached_base_dev = acc_init_1 (d, acc_construct_runtime_api, 0);
gomp_mutex_unlock (&acc_device_lock);
goacc_attach_host_thread_to_device (-1);
@@ -529,6 +598,12 @@ acc_set_device_type (acc_device_t d)
struct gomp_device_descr *base_dev, *acc_dev;
struct goacc_thread *thr = goacc_thread ();
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ prof_info.device_type = d;
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
@@ -553,6 +628,12 @@ acc_set_device_type (acc_device_t d)
}
goacc_attach_host_thread_to_device (-1);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
ialias (acc_set_device_type)
@@ -588,12 +669,22 @@ acc_get_device_type (void)
;
else
{
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (acc_device_default, true);
gomp_mutex_unlock (&acc_device_lock);
res = acc_device_type (dev->type);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
assert (res != acc_device_default
@@ -614,12 +705,24 @@ acc_get_device_num (acc_device_t d)
if (d >= _ACC_device_hwm)
gomp_fatal ("unknown device type %u", (unsigned) d);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ prof_info.device_type = d;
+
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (d, true);
gomp_mutex_unlock (&acc_device_lock);
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
if (thr && thr->base_dev == dev && thr->dev)
return thr->dev->target_id;
@@ -813,8 +916,13 @@ goacc_lazy_initialize (void)
if (thr && thr->dev)
return;
+ gomp_init_targets_once ();
+
+ gomp_mutex_lock (&acc_device_lock);
if (!cached_base_dev)
- acc_init (acc_device_default);
- else
- goacc_attach_host_thread_to_device (-1);
+ cached_base_dev = acc_init_1 (acc_device_default,
+ acc_construct_parallel, 1);
+ gomp_mutex_unlock (&acc_device_lock);
+
+ goacc_attach_host_thread_to_device (-1);
}
diff --git a/libgomp/oacc-int.h b/libgomp/oacc-int.h
index e4b6ea6..5ca9944 100644
--- a/libgomp/oacc-int.h
+++ b/libgomp/oacc-int.h
@@ -40,6 +40,7 @@
#include "openacc.h"
#include "config.h"
+#include "acc_prof.h"
#include <stddef.h>
#include <stdbool.h>
#include <stdarg.h>
@@ -68,6 +69,12 @@ struct goacc_thread
strictly push/pop semantics according to lexical scope. */
struct target_mem_desc *mapped_data;
+ /* Data of the OpenACC Profiling Interface. */
+ acc_prof_info *prof_info;
+ acc_api_info *api_info;
+ /* Per-thread toggle of OpenACC Profiling Interface callbacks. */
+ bool prof_callbacks_enabled;
+
/* These structures form a list: this is the next thread in that list. */
struct goacc_thread *next;
@@ -128,6 +135,28 @@ async_synchronous_p (int async)
return async == acc_async_sync;
}
+
+extern bool goacc_prof_enabled;
+/* Tune for the (very common) case that profiling is not enabled. */
+#define GOACC_PROF_ENABLED \
+ (__builtin_expect (__atomic_load_n (&goacc_prof_enabled, \
+ MEMMODEL_ACQUIRE) == true, false))
+
+void goacc_profiling_initialize (void);
+bool _goacc_profiling_dispatch_p (bool);
+/* Tune for the (very common) case that profiling is not enabled. */
+#define GOACC_PROFILING_DISPATCH_P(...) \
+ (GOACC_PROF_ENABLED \
+ && _goacc_profiling_dispatch_p (__VA_ARGS__))
+bool _goacc_profiling_setup_p (struct goacc_thread *,
+ acc_prof_info *, acc_api_info *);
+/* Tune for the (very common) case that profiling is not enabled. */
+#define GOACC_PROFILING_SETUP_P(...) \
+ (GOACC_PROFILING_DISPATCH_P (false) \
+ && _goacc_profiling_setup_p (__VA_ARGS__))
+void goacc_profiling_dispatch (acc_prof_info *, acc_event_info *,
+ acc_api_info *);
+
#ifdef HAVE_ATTRIBUTE_VISIBILITY
# pragma GCC visibility pop
#endif
diff --git a/libgomp/oacc-mem.c b/libgomp/oacc-mem.c
index b3b3777..c07a5eb 100644
--- a/libgomp/oacc-mem.c
+++ b/libgomp/oacc-mem.c
@@ -104,7 +104,19 @@ acc_malloc (size_t s)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return malloc (s);
- return thr->dev->alloc_func (thr->dev->target_id, s);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
+ void *res = thr->dev->alloc_func (thr->dev->target_id, s);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
+ return res;
}
/* OpenACC 2.0a (3.2.16) doesn't specify what to do in the event
@@ -127,6 +139,10 @@ acc_free (void *d)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return free (d);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
gomp_mutex_lock (&acc_dev->lock);
/* We don't have to call lazy open here, as the ptr value must have
@@ -147,6 +163,12 @@ acc_free (void *d)
if (!acc_dev->free_func (acc_dev->target_id, d))
gomp_fatal ("error in freeing device memory in %s", __FUNCTION__);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
@@ -168,11 +190,26 @@ memcpy_tofrom_device (bool from, void *d, void *h, size_t s, int async,
return;
}
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
goacc_aq aq = get_goacc_asyncqueue (async);
if (from)
gomp_copy_dev2host (thr->dev, aq, h, d, s);
else
gomp_copy_host2dev (thr->dev, aq, d, h, s, /* TODO: cbuf? */ NULL);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -217,6 +254,9 @@ acc_deviceptr (void *h)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&dev->lock);
n = lookup_host (dev, h, 1);
@@ -254,6 +294,9 @@ acc_hostptr (void *d)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return d;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_dev (&acc_dev->mem_map, d, 1);
@@ -291,6 +334,9 @@ acc_is_present (void *h, size_t s)
if (thr->dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h != NULL;
+ /* In the following, no OpenACC Profiling Interface events can possibly be
+ generated. */
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -335,6 +381,10 @@ acc_map_data (void *h, void *d, size_t s)
gomp_fatal ("[%p,+%d]->[%p,+%d] is a bad map",
(void *)h, (int)s, (void *)d, (int)s);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
gomp_mutex_lock (&acc_dev->lock);
if (lookup_host (acc_dev, h, s))
@@ -356,6 +406,12 @@ acc_map_data (void *h, void *d, size_t s)
tgt = gomp_map_vars (acc_dev, mapnum, &hostaddrs, &devaddrs, &sizes,
&kinds, true, GOMP_MAP_VARS_OPENACC);
tgt->list[0].key->refcount = REFCOUNT_INFINITY;
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
}
@@ -372,6 +428,10 @@ acc_unmap_data (void *h)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
gomp_mutex_lock (&acc_dev->lock);
cur_node.host_start = (uintptr_t) h;
@@ -405,6 +465,12 @@ acc_unmap_data (void *h)
}
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
#define FLAG_PRESENT (1 << 0)
@@ -428,6 +494,15 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return h;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -489,6 +564,12 @@ present_create_copy (unsigned f, void *h, size_t s, int async)
gomp_mutex_unlock (&acc_dev->lock);
}
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return d;
}
@@ -569,6 +650,15 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
if (acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -627,6 +717,12 @@ delete_copyout (unsigned f, void *h, size_t s, int async, const char *libfnname)
}
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -698,6 +794,15 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
if (h == NULL)
return;
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
gomp_mutex_lock (&acc_dev->lock);
n = lookup_host (acc_dev, h, s);
@@ -719,6 +824,12 @@ update_dev_host (int is_dev, void *h, size_t s, int async)
gomp_copy_dev2host (acc_dev, aq, h, d, s);
gomp_mutex_unlock (&acc_dev->lock);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
diff --git a/libgomp/oacc-parallel.c b/libgomp/oacc-parallel.c
index b949599..c798578 100644
--- a/libgomp/oacc-parallel.c
+++ b/libgomp/oacc-parallel.c
@@ -205,21 +205,75 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
thr = goacc_thread ();
acc_dev = thr->dev;
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (true);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_compute_construct_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info compute_construct_event_info;
+ if (profiling_p)
+ {
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ compute_construct_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ compute_construct_event_info.other_event.parent_construct
+ = acc_construct_parallel;
+ compute_construct_event_info.other_event.implicit = 0;
+ compute_construct_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds);
/* Host fallback if "if" clause is false or if the current device is set to
the host. */
if (flags & GOACC_FLAG_HOST_FALLBACK)
{
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
goacc_save_and_set_bind (acc_device_host);
goacc_call_host_fn (fn, mapnum, hostaddrs, params);
goacc_restore_bind ();
- return;
+ goto out_prof;
}
else if (acc_device_type (acc_dev->type) == acc_device_host)
{
goacc_call_host_fn (fn, mapnum, hostaddrs, params);
- return;
+ goto out_prof;
}
/* Default: let the runtime choose. */
@@ -252,6 +306,13 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
if (async == GOMP_LAUNCH_OP_MAX)
async = va_arg (*ap, unsigned);
+
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
break;
}
@@ -284,6 +345,22 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
else
tgt_fn = (void (*)) fn;
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_start;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = compute_construct_event_info.other_event.parent_construct;
+ enter_exit_data_event_info.other_event.implicit = 1;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
+
goacc_aq aq = get_goacc_asyncqueue (async);
tgt = gomp_map_vars_async (acc_dev, aq, mapnum, hostaddrs, NULL, sizes, kinds,
@@ -298,6 +375,15 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
gomp_mutex_unlock (&acc_dev->lock);
#endif
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
+
devaddrs = gomp_alloca (sizeof (void *) * mapnum);
for (i = 0; i < mapnum; i++)
devaddrs[i] = (void *) gomp_map_val (tgt, hostaddrs, i);
@@ -310,8 +396,6 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
else
acc_dev->openacc.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs,
dims, tgt);
- /* If running synchronously, unmap immediately. */
- gomp_unmap_vars (tgt, true);
}
else
{
@@ -321,7 +405,29 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
else
acc_dev->openacc.async.exec_func (tgt_fn, mapnum, hostaddrs,
devaddrs, dims, tgt, aq);
- gomp_unmap_vars_async (tgt, true, aq);
+ }
+
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_start;
+ enter_exit_data_event_info.other_event.event_type = prof_info.event_type;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+ }
+
+ /* If running synchronously, unmap immediately. */
+ if (aq == NULL)
+ gomp_unmap_vars (tgt, true);
+ else
+ gomp_unmap_vars_async (tgt, true, aq);
+
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
}
#ifdef RC_CHECKING
@@ -329,6 +435,19 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
gomp_rc_check (acc_dev, thr->mapped_data);
gomp_mutex_unlock (&acc_dev->lock);
#endif
+
+ out_prof:
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_compute_construct_end;
+ compute_construct_event_info.other_event.event_type
+ = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &compute_construct_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -390,6 +509,71 @@ GOACC_data_start (int flags_m, size_t mapnum,
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (true);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_enter_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info enter_data_event_info;
+ if (profiling_p)
+ {
+ enter_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_data_event_info.other_event.parent_construct = acc_construct_data;
+ for (int i = 0; i < mapnum; ++i)
+ if ((kinds[i] & 0xff) == GOMP_MAP_USE_DEVICE_PTR)
+ {
+ /* If there is one such data mapping kind, then this is actually an
+ OpenACC 'host_data' construct. (GCC maps the OpenACC
+ 'host_data' construct to the OpenACC 'data' construct.) Apart
+ from artificial test cases (such as an OpenACC 'host_data'
+ construct's (implicit) device initialization when there hasn't
+ been any device data be set up before...), there can't really
+ any meaningful events be generated from OpenACC 'host_data'
+ constructs, though. */
+ enter_data_event_info.other_event.parent_construct
+ = acc_construct_host_data;
+ break;
+ }
+ enter_data_event_info.other_event.implicit = 0;
+ enter_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds);
enum gomp_map_vars_kind pragma_kind;
@@ -402,11 +586,13 @@ GOACC_data_start (int flags_m, size_t mapnum,
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| (flags & GOACC_FLAG_HOST_FALLBACK))
{
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
tgt = gomp_map_vars (NULL, 0, NULL, NULL, NULL, NULL, true, pragma_kind);
tgt->prev = thr->mapped_data;
thr->mapped_data = tgt;
- return;
+ goto out_prof;
}
gomp_debug (0, " %s: prepare mappings\n", __FUNCTION__);
@@ -421,14 +607,76 @@ GOACC_data_start (int flags_m, size_t mapnum,
gomp_rc_check (acc_dev, thr->mapped_data);
gomp_mutex_unlock (&acc_dev->lock);
#endif
+
+out_prof:
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_enter_data_end;
+ enter_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_data_end (void)
{
struct goacc_thread *thr = goacc_thread ();
+ struct gomp_device_descr *acc_dev = thr->dev;
struct target_mem_desc *tgt = thr->mapped_data;
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (true);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = acc_async_sync; /* Always synchronous. */
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info exit_data_event_info;
+ if (profiling_p)
+ {
+ exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ exit_data_event_info.other_event.parent_construct = acc_construct_data;
+ exit_data_event_info.other_event.implicit = 0;
+ exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
gomp_debug (0, " %s: restore mappings\n", __FUNCTION__);
thr->mapped_data = tgt->prev;
gomp_unmap_vars (tgt, true);
@@ -439,6 +687,16 @@ GOACC_data_end (void)
gomp_rc_check (thr->dev, thr->mapped_data);
gomp_mutex_unlock (&thr->dev->lock);
#endif
+
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_exit_data_end;
+ exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
@@ -458,19 +716,6 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
thr = goacc_thread ();
acc_dev = thr->dev;
- if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
- || (flags & GOACC_FLAG_HOST_FALLBACK))
- return;
-
- if (num_waits)
- {
- va_list ap;
-
- va_start (ap, num_waits);
- goacc_wait (async, num_waits, &ap);
- va_end (ap);
- }
-
/* Determine whether "finalize" semantics apply to all mappings of this
OpenACC directive. */
bool finalize = false;
@@ -521,6 +766,77 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
kind);
}
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (true);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type
+ = data_enter ? acc_ev_enter_data_start : acc_ev_exit_data_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info enter_exit_data_event_info;
+ if (profiling_p)
+ {
+ enter_exit_data_event_info.other_event.event_type
+ = prof_info.event_type;
+ enter_exit_data_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ enter_exit_data_event_info.other_event.parent_construct
+ = data_enter ? acc_construct_enter_data : acc_construct_exit_data;
+ enter_exit_data_event_info.other_event.implicit = 0;
+ enter_exit_data_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
+ || (flags & GOACC_FLAG_HOST_FALLBACK))
+ {
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+
+ goto out_prof;
+ }
+
+ if (num_waits)
+ {
+ va_list ap;
+
+ va_start (ap, num_waits);
+ goacc_wait (async, num_waits, &ap);
+ va_end (ap);
+ }
+
/* In c, non-pointers and arrays are represented by a single data clause.
Dynamically allocated arrays and subarrays are represented by a data
clause followed by an internal GOMP_MAP_POINTER.
@@ -739,6 +1055,19 @@ GOACC_enter_exit_data (int flags_m, size_t mapnum,
gomp_rc_check (acc_dev, thr->mapped_data);
gomp_mutex_unlock (&acc_dev->lock);
#endif
+
+ out_prof:
+ if (profiling_p)
+ {
+ prof_info.event_type
+ = data_enter ? acc_ev_enter_data_end : acc_ev_exit_data_end;
+ enter_exit_data_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info,
+ &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
static void
@@ -787,9 +1116,64 @@ GOACC_update (int flags_m, size_t mapnum,
struct goacc_thread *thr = goacc_thread ();
struct gomp_device_descr *acc_dev = thr->dev;
+ bool profiling_p = GOACC_PROFILING_DISPATCH_P (true);
+
+ acc_prof_info prof_info;
+ if (profiling_p)
+ {
+ thr->prof_info = &prof_info;
+
+ prof_info.event_type = acc_ev_update_start;
+ prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info.version = _ACC_PROF_INFO_VERSION;
+ prof_info.device_type = acc_device_type (acc_dev->type);
+ prof_info.device_number = acc_dev->target_id;
+ prof_info.thread_id = -1;
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ prof_info.src_file = NULL;
+ prof_info.func_name = NULL;
+ prof_info.line_no = -1;
+ prof_info.end_line_no = -1;
+ prof_info.func_line_no = -1;
+ prof_info.func_end_line_no = -1;
+ }
+ acc_event_info update_event_info;
+ if (profiling_p)
+ {
+ update_event_info.other_event.event_type
+ = prof_info.event_type;
+ update_event_info.other_event.valid_bytes
+ = _ACC_OTHER_EVENT_INFO_VALID_BYTES;
+ update_event_info.other_event.parent_construct = acc_construct_update;
+ update_event_info.other_event.implicit = 0;
+ update_event_info.other_event.tool_info = NULL;
+ }
+ acc_api_info api_info;
+ if (profiling_p)
+ {
+ thr->api_info = &api_info;
+
+ api_info.device_api = acc_device_api_none;
+ api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info.device_type = prof_info.device_type;
+ api_info.vendor = -1;
+ api_info.device_handle = NULL;
+ api_info.context_handle = NULL;
+ api_info.async_handle = NULL;
+ }
+
+ if (profiling_p)
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|| (flags & GOACC_FLAG_HOST_FALLBACK))
- return;
+ {
+ prof_info.device_type = acc_device_host;
+ api_info.device_type = prof_info.device_type;
+
+ goto out_prof;
+ }
if (num_waits)
{
@@ -861,11 +1245,38 @@ GOACC_update (int flags_m, size_t mapnum,
break;
}
}
+
+ out_prof:
+ if (profiling_p)
+ {
+ prof_info.event_type = acc_ev_update_end;
+ update_event_info.other_event.event_type = prof_info.event_type;
+ goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info);
+
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
void
GOACC_wait (int async, int num_waits, ...)
{
+ goacc_lazy_initialize ();
+
+ struct goacc_thread *thr = goacc_thread ();
+
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+ if (profiling_p)
+ {
+ prof_info.async = async;
+ prof_info.async_queue = prof_info.async;
+ }
+
if (num_waits)
{
va_list ap;
@@ -878,6 +1289,12 @@ GOACC_wait (int async, int num_waits, ...)
acc_wait_all ();
else
acc_wait_all_async (async);
+
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
}
int
diff --git a/libgomp/oacc-plugin.c b/libgomp/oacc-plugin.c
index 5480c1d..b4f71a1 100644
--- a/libgomp/oacc-plugin.c
+++ b/libgomp/oacc-plugin.c
@@ -29,6 +29,7 @@
#include "libgomp.h"
#include "oacc-plugin.h"
#include "oacc-int.h"
+#include "acc_prof.h"
/* This plugin function is now obsolete. */
void
@@ -38,6 +39,14 @@ GOMP_PLUGIN_async_unmap_vars (void *ptr __attribute__((unused)),
gomp_fatal ("invalid plugin function");
}
+/* Return the TLS data for the current thread. */
+
+struct goacc_thread *
+GOMP_PLUGIN_goacc_thread (void)
+{
+ return goacc_thread ();
+}
+
/* Return the target-specific part of the TLS data for the current thread. */
void *
@@ -57,3 +66,11 @@ GOMP_PLUGIN_acc_default_dim (unsigned int i)
}
return goacc_default_dims[i];
}
+
+void
+GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *prof_info,
+ acc_event_info *event_info,
+ acc_api_info *api_info)
+{
+ goacc_profiling_dispatch (prof_info, event_info, api_info);
+}
diff --git a/libgomp/oacc-plugin.h b/libgomp/oacc-plugin.h
index 112d4a59..887c6f6 100644
--- a/libgomp/oacc-plugin.h
+++ b/libgomp/oacc-plugin.h
@@ -27,8 +27,15 @@
#ifndef OACC_PLUGIN_H
#define OACC_PLUGIN_H 1
+#include "oacc-int.h"
+#include "acc_prof.h"
+
extern void GOMP_PLUGIN_async_unmap_vars (void *, int);
+extern struct goacc_thread *GOMP_PLUGIN_goacc_thread (void);
extern void *GOMP_PLUGIN_acc_thread (void);
extern int GOMP_PLUGIN_acc_default_dim (unsigned int);
+extern void GOMP_PLUGIN_goacc_profiling_dispatch (acc_prof_info *,
+ acc_event_info *,
+ acc_api_info *);
#endif
diff --git a/libgomp/oacc-profiling.c b/libgomp/oacc-profiling.c
new file mode 100644
index 0000000..eff2886
--- /dev/null
+++ b/libgomp/oacc-profiling.c
@@ -0,0 +1,662 @@
+/* OpenACC Profiling Interface
+
+ Copyright (C) 2019 Free Software Foundation, Inc.
+
+ Contributed by Mentor, a Siemens Business.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+#define _GNU_SOURCE
+#include "libgomp.h"
+#include "oacc-int.h"
+#include "secure_getenv.h"
+#include "acc_prof.h"
+#include <assert.h>
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+#ifdef PLUGIN_SUPPORT
+# include <dlfcn.h>
+#endif
+
+#define STATIC_ASSERT(expr) _Static_assert (expr, "!(" #expr ")")
+
+/* Statically assert that the layout of the common fields in the
+ 'acc_event_info' variants matches. */
+/* 'event_type' */
+STATIC_ASSERT (offsetof (acc_event_info, event_type)
+ == offsetof (acc_event_info, data_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, launch_event.event_type));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.event_type)
+ == offsetof (acc_event_info, other_event.event_type));
+/* 'valid_bytes' */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, launch_event.valid_bytes));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.valid_bytes)
+ == offsetof (acc_event_info, other_event.valid_bytes));
+/* 'parent_construct' */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, launch_event.parent_construct));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.parent_construct)
+ == offsetof (acc_event_info, other_event.parent_construct));
+/* 'implicit' */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, launch_event.implicit));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.implicit)
+ == offsetof (acc_event_info, other_event.implicit));
+/* 'tool_info' */
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, launch_event.tool_info));
+STATIC_ASSERT (offsetof (acc_event_info, data_event.tool_info)
+ == offsetof (acc_event_info, other_event.tool_info));
+
+struct goacc_prof_callback_entry
+{
+ acc_prof_callback cb;
+ int ref;
+ bool enabled;
+ struct goacc_prof_callback_entry *next;
+};
+
+/* Use a separate flag to minimize run-time performance impact for the (very
+ common) case that profiling is not enabled.
+
+ Once enabled, we're not going to disable this anymore, anywhere. We
+ probably could, by adding appropriate logic to 'acc_prof_register',
+ 'acc_prof_unregister'. */
+bool goacc_prof_enabled = false;
+
+/* Global state for registered callbacks.
+ 'goacc_prof_callbacks_enabled[acc_ev_none]' acts as a global toggle. */
+static bool goacc_prof_callbacks_enabled[acc_ev_last];
+static struct goacc_prof_callback_entry *goacc_prof_callback_entries[acc_ev_last];
+/* Lock used to protect access to 'goacc_prof_callbacks_enabled', and
+ 'goacc_prof_callback_entries'. */
+static gomp_mutex_t goacc_prof_lock;
+
+void
+goacc_profiling_initialize (void)
+{
+ gomp_mutex_init (&goacc_prof_lock);
+
+ /* Initially, all callbacks for all events are enabled. */
+ for (int i = 0; i < acc_ev_last; ++i)
+ goacc_prof_callbacks_enabled[i] = true;
+
+
+#ifdef PLUGIN_SUPPORT
+ char *acc_proflibs = secure_getenv ("ACC_PROFLIB");
+ while (acc_proflibs != NULL && acc_proflibs[0] != '\0')
+ {
+ char *acc_proflibs_sep = strchr (acc_proflibs, ';');
+ char *acc_proflib;
+ if (acc_proflibs_sep == acc_proflibs)
+ {
+ /* Stray ';' separator: make sure we don't 'dlopen' the main
+ program. */
+ acc_proflib = NULL;
+ }
+ else
+ {
+ if (acc_proflibs_sep != NULL)
+ {
+ /* Single out the first library. */
+ acc_proflib = gomp_malloc (acc_proflibs_sep - acc_proflibs + 1);
+ memcpy (acc_proflib, acc_proflibs,
+ acc_proflibs_sep - acc_proflibs);
+ acc_proflib[acc_proflibs_sep - acc_proflibs] = '\0';
+ }
+ else
+ {
+ /* No ';' separator, so only one library. */
+ acc_proflib = acc_proflibs;
+ }
+
+ gomp_debug (0, "%s: dlopen (\"%s\")\n", __FUNCTION__, acc_proflib);
+ void *dl_handle = dlopen (acc_proflib, RTLD_LAZY);
+ if (dl_handle != NULL)
+ {
+ typeof (&acc_register_library) a_r_l
+ = dlsym (dl_handle, "acc_register_library");
+ if (a_r_l == NULL)
+ goto dl_fail;
+ gomp_debug (0, " %s: calling %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ a_r_l (acc_prof_register, acc_prof_unregister,
+ acc_prof_lookup);
+ }
+ else
+ {
+ dl_fail:
+ gomp_error ("while loading ACC_PROFLIB \"%s\": %s",
+ acc_proflib, dlerror ());
+ if (dl_handle != NULL)
+ {
+ int err = dlclose (dl_handle);
+ dl_handle = NULL;
+ if (err != 0)
+ goto dl_fail;
+ }
+ }
+ }
+
+ if (acc_proflib != acc_proflibs)
+ {
+ free (acc_proflib);
+
+ acc_proflibs = acc_proflibs_sep + 1;
+ }
+ else
+ acc_proflibs = NULL;
+ }
+#endif /* PLUGIN_SUPPORT */
+}
+
+void
+acc_prof_register (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+
+ /* For any events to be dispatched, the user first has to register a
+ callback, which makes this here a good place for enabling the whole
+ machinery. */
+ if (!GOACC_PROF_ENABLED)
+ __atomic_store_n (&goacc_prof_enabled, true, MEMMODEL_RELEASE);
+
+
+ enum
+ {
+ EVENT_KIND_BOGUS,
+ EVENT_KIND_NORMAL,
+ /* As end events invoke callbacks in the reverse order, we register these
+ in the reverse order here. */
+ EVENT_KIND_END,
+ } event_kind = EVENT_KIND_BOGUS;
+ switch (ev)
+ {
+ case acc_ev_none:
+ case acc_ev_device_init_start:
+ case acc_ev_device_shutdown_start:
+ case acc_ev_runtime_shutdown:
+ case acc_ev_create:
+ case acc_ev_delete:
+ case acc_ev_alloc:
+ case acc_ev_free:
+ case acc_ev_enter_data_start:
+ case acc_ev_exit_data_start:
+ case acc_ev_update_start:
+ case acc_ev_compute_construct_start:
+ case acc_ev_enqueue_launch_start:
+ case acc_ev_enqueue_upload_start:
+ case acc_ev_enqueue_download_start:
+ case acc_ev_wait_start:
+ event_kind = EVENT_KIND_NORMAL;
+ break;
+ case acc_ev_device_init_end:
+ case acc_ev_device_shutdown_end:
+ case acc_ev_enter_data_end:
+ case acc_ev_exit_data_end:
+ case acc_ev_update_end:
+ case acc_ev_compute_construct_end:
+ case acc_ev_enqueue_launch_end:
+ case acc_ev_enqueue_upload_end:
+ case acc_ev_enqueue_download_end:
+ case acc_ev_wait_end:
+ event_kind = EVENT_KIND_END;
+ break;
+ case acc_ev_last:
+ break;
+ }
+ if (event_kind == EVENT_KIND_BOGUS)
+ {
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring request for bogus 'acc_event_t'\n");
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring request with bogus 'acc_register_t'\n");
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally enabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* For 'acc_ev_none', this acts as a global toggle. */
+ goacc_prof_callbacks_enabled[ev] = true;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: enabling callbacks\n");
+ goacc_lazy_initialize ();
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = true;
+ return;
+ }
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring bogus request\n");
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ /* If we already have this callback registered, just increment its
+ reference count. */
+ if (it != NULL)
+ {
+ it->ref++;
+ gomp_debug (0, " already registered;"
+ " incrementing reference count to: %d\n", it->ref);
+ }
+ else
+ {
+ struct goacc_prof_callback_entry *e
+ = gomp_malloc (sizeof (struct goacc_prof_callback_entry));
+ e->cb = cb;
+ e->ref = 1;
+ e->enabled = true;
+ bool prepend = (event_kind == EVENT_KIND_END);
+ /* If we don't have any callback registered yet, also use the
+ 'prepend' code path. */
+ if (it_p == NULL)
+ prepend = true;
+ if (prepend)
+ {
+ gomp_debug (0, " prepending\n");
+ e->next = goacc_prof_callback_entries[ev];
+ goacc_prof_callback_entries[ev] = e;
+ }
+ else
+ {
+ gomp_debug (0, " appending\n");
+ e->next = NULL;
+ it_p->next = e;
+ }
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ gomp_debug (0, " ignoring request: is not registered\n");
+ break;
+ }
+ else
+ {
+ gomp_debug (0, " enabling\n");
+ it->enabled = true;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+void
+acc_prof_unregister (acc_event_t ev, acc_prof_callback cb, acc_register_t reg)
+{
+ gomp_debug (0, "%s: ev=%d, cb=%p, reg=%d\n",
+ __FUNCTION__, (int) ev, (void *) cb, (int) reg);
+
+ /* If profiling is not enabled, there cannot be anything to unregister. */
+ if (!GOACC_PROF_ENABLED)
+ return;
+
+ if (ev < acc_ev_none
+ || ev >= acc_ev_last)
+ {
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring request for bogus 'acc_event_t'\n");
+ return;
+ }
+
+ bool bogus = true;
+ switch (reg)
+ {
+ case acc_reg:
+ case acc_toggle:
+ case acc_toggle_per_thread:
+ bogus = false;
+ break;
+ }
+ if (bogus)
+ {
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring request with bogus 'acc_register_t'\n");
+ return;
+ }
+
+ /* Special cases. */
+ if (reg == acc_toggle)
+ {
+ if (cb == NULL)
+ {
+ gomp_debug (0, " globally disabling callbacks\n");
+ gomp_mutex_lock (&goacc_prof_lock);
+ /* For 'acc_ev_none', this acts as a global toggle. */
+ goacc_prof_callbacks_enabled[ev] = false;
+ gomp_mutex_unlock (&goacc_prof_lock);
+ return;
+ }
+ else if (ev == acc_ev_none && cb != NULL)
+ {
+ gomp_debug (0, " ignoring request\n");
+ return;
+ }
+ }
+ else if (reg == acc_toggle_per_thread)
+ {
+ if (ev == acc_ev_none && cb == NULL)
+ {
+ gomp_debug (0, " thread: disabling callbacks\n");
+ goacc_lazy_initialize ();
+ struct goacc_thread *thr = goacc_thread ();
+ thr->prof_callbacks_enabled = false;
+ return;
+ }
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring bogus request\n");
+ return;
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ struct goacc_prof_callback_entry *it, *it_p;
+ it = goacc_prof_callback_entries[ev];
+ it_p = NULL;
+ while (it)
+ {
+ if (it->cb == cb)
+ break;
+ it_p = it;
+ it = it->next;
+ }
+
+ switch (reg)
+ {
+ case acc_reg:
+ if (it == NULL)
+ {
+ /* Silently ignore. */
+ gomp_debug (0, " ignoring bogus request: is not registered\n");
+ break;
+ }
+ it->ref--;
+ gomp_debug (0, " decrementing reference count to: %d\n", it->ref);
+ if (it->ref == 0)
+ {
+ if (it_p == NULL)
+ goacc_prof_callback_entries[ev] = it->next;
+ else
+ it_p->next = it->next;
+ free (it);
+ }
+ break;
+
+ case acc_toggle:
+ if (it == NULL)
+ {
+ gomp_debug (0, " ignoring request: is not registered\n");
+ break;
+ }
+ else
+ {
+ gomp_debug (0, " disabling\n");
+ it->enabled = false;
+ }
+ break;
+
+ case acc_toggle_per_thread:
+ __builtin_unreachable ();
+ }
+
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
+
+acc_query_fn
+acc_prof_lookup (const char *name)
+{
+ gomp_debug (0, "%s (%s)\n",
+ __FUNCTION__, name ?: "NULL");
+
+ return NULL;
+}
+
+void
+acc_register_library (acc_prof_reg reg, acc_prof_reg unreg,
+ acc_prof_lookup_func lookup)
+{
+ gomp_fatal ("TODO");
+}
+
+/* Prepare to dispatch events? */
+
+bool
+_goacc_profiling_dispatch_p (bool check_not_nested_p)
+{
+ gomp_debug (0, "%s\n", __FUNCTION__);
+
+ bool ret;
+
+ struct goacc_thread *thr = goacc_thread ();
+ if (__builtin_expect (thr == NULL, false))
+ {
+ /* If we don't have any per-thread state yet, that means that per-thread
+ callback dispatch has not been explicitly disabled (which only a call
+ to 'acc_prof_unregister' with 'acc_toggle_per_thread' would do, and
+ that would have allocated per-thread state via
+ 'goacc_lazy_initialize'); initially, all callbacks for all events are
+ enabled. */
+ gomp_debug (0, " %s: don't have any per-thread state yet\n", __FUNCTION__);
+ }
+ else
+ {
+ if (check_not_nested_p)
+ {
+ /* No nesting. */
+ assert (thr->prof_info == NULL);
+ assert (thr->api_info == NULL);
+ }
+
+ if (__builtin_expect (!thr->prof_callbacks_enabled, true))
+ {
+ gomp_debug (0, " %s: disabled for this thread\n", __FUNCTION__);
+ ret = false;
+ goto out;
+ }
+ }
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ /* 'goacc_prof_callbacks_enabled[acc_ev_none]' acts as a global toggle. */
+ if (__builtin_expect (!goacc_prof_callbacks_enabled[acc_ev_none], true))
+ {
+ gomp_debug (0, " %s: disabled globally\n", __FUNCTION__);
+ ret = false;
+ goto out_unlock;
+ }
+ else
+ ret = true;
+
+ out_unlock:
+ gomp_mutex_unlock (&goacc_prof_lock);
+
+ out:
+ return ret;
+}
+
+/* Set up to dispatch events? */
+
+bool
+_goacc_profiling_setup_p (struct goacc_thread *thr,
+ acc_prof_info *prof_info, acc_api_info *api_info)
+{
+ gomp_debug (0, "%s (%p)\n", __FUNCTION__, thr);
+
+ /* If we don't have any per-thread state yet, we can't register 'prof_info'
+ and 'api_info'. */
+ if (__builtin_expect (thr == NULL, false))
+ {
+ gomp_debug (0, "Can't dispatch OpenACC Profiling Interface events for"
+ " the current call, construct, or directive\n");
+ return false;
+ }
+
+ if (thr->prof_info != NULL)
+ {
+ /* Profiling has already been set up for an outer construct. In this
+ case, we continue to use the existing information, and thus return
+ 'false' here.
+
+ This can happen, for example, for an 'enter data' directive, which
+ sets up profiling, then calls into 'acc_copyin', which should not
+ again set up profiling, should not overwrite the existing
+ information. */
+ return false;
+ }
+
+ thr->prof_info = prof_info;
+ thr->api_info = api_info;
+
+ /* Fill in some defaults. */
+
+ prof_info->event_type = -1; /* Must be set later. */
+ prof_info->valid_bytes = _ACC_PROF_INFO_VALID_BYTES;
+ prof_info->version = _ACC_PROF_INFO_VERSION;
+ if (thr->dev)
+ {
+ prof_info->device_type = acc_device_type (thr->dev->type);
+ prof_info->device_number = thr->dev->target_id;
+ }
+ else
+ {
+ prof_info->device_type = -1;
+ prof_info->device_number = -1;
+ }
+ prof_info->thread_id = -1;
+ prof_info->async = acc_async_sync;
+ prof_info->async_queue = prof_info->async;
+ prof_info->src_file = NULL;
+ prof_info->func_name = NULL;
+ prof_info->line_no = -1;
+ prof_info->end_line_no = -1;
+ prof_info->func_line_no = -1;
+ prof_info->func_end_line_no = -1;
+
+ api_info->device_api = acc_device_api_none;
+ api_info->valid_bytes = _ACC_API_INFO_VALID_BYTES;
+ api_info->device_type = prof_info->device_type;
+ api_info->vendor = -1;
+ api_info->device_handle = NULL;
+ api_info->context_handle = NULL;
+ api_info->async_handle = NULL;
+
+ return true;
+}
+
+/* Dispatch events.
+
+ This must only be called if 'GOACC_PROFILING_DISPATCH_P' or
+ 'GOACC_PROFILING_SETUP_P' returned a true result. */
+
+void
+goacc_profiling_dispatch (acc_prof_info *prof_info, acc_event_info *event_info,
+ acc_api_info *apt_info)
+{
+ acc_event_t event_type = event_info->event_type;
+ gomp_debug (0, "%s: event_type=%d\n", __FUNCTION__, (int) event_type);
+ assert (event_type > acc_ev_none
+ && event_type < acc_ev_last);
+
+ gomp_mutex_lock (&goacc_prof_lock);
+
+ if (!goacc_prof_callbacks_enabled[event_type])
+ {
+ gomp_debug (0, " disabled for this event type\n");
+
+ goto out_unlock;
+ }
+
+ for (struct goacc_prof_callback_entry *e
+ = goacc_prof_callback_entries[event_type];
+ e != NULL;
+ e = e->next)
+ {
+ if (!e->enabled)
+ {
+ gomp_debug (0, " disabled for callback %p\n", e->cb);
+ continue;
+ }
+
+ gomp_debug (0, " calling callback %p\n", e->cb);
+ e->cb (prof_info, event_info, apt_info);
+ }
+
+ out_unlock:
+ gomp_mutex_unlock (&goacc_prof_lock);
+}
diff --git a/libgomp/plugin/plugin-nvptx.c b/libgomp/plugin/plugin-nvptx.c
index cb18e87..09567ce 100644
--- a/libgomp/plugin/plugin-nvptx.c
+++ b/libgomp/plugin/plugin-nvptx.c
@@ -37,6 +37,7 @@
#include "libgomp-plugin.h"
#include "oacc-plugin.h"
#include "gomp-constants.h"
+#include "oacc-int.h"
#include <pthread.h>
#include <cuda.h>
@@ -903,26 +904,121 @@ nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,
// num_gangs nctaid.x
// num_workers ntid.y
// vector length ntid.x
+
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info enqueue_launch_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_p = __builtin_expect (prof_info != NULL, false);
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_start;
+
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ enqueue_launch_event_info.launch_event.valid_bytes
+ = _ACC_LAUNCH_EVENT_INFO_VALID_BYTES;
+ enqueue_launch_event_info.launch_event.parent_construct
+ = acc_construct_parallel;
+ enqueue_launch_event_info.launch_event.implicit = 1;
+ enqueue_launch_event_info.launch_event.tool_info = NULL;
+ enqueue_launch_event_info.launch_event.kernel_name = targ_fn->launch->fn;
+ enqueue_launch_event_info.launch_event.num_gangs
+ = dims[GOMP_DIM_GANG];
+ enqueue_launch_event_info.launch_event.num_workers
+ = dims[GOMP_DIM_WORKER];
+ enqueue_launch_event_info.launch_event.vector_length
+ = dims[GOMP_DIM_VECTOR];
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
+
CUDA_CALL_ASSERT (cuLaunchKernel, function,
dims[GOMP_DIM_GANG], 1, 1,
dims[GOMP_DIM_VECTOR], dims[GOMP_DIM_WORKER], 1,
0, stream, kargs, 0);
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_launch_end;
+ enqueue_launch_event_info.launch_event.event_type
+ = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &enqueue_launch_event_info,
+ api_info);
+ }
+
GOMP_PLUGIN_debug (0, " %s: kernel %s: finished\n", __FUNCTION__,
targ_fn->launch->fn);
}
void * openacc_get_current_cuda_context (void);
+static void
+goacc_profiling_acc_ev_alloc (struct goacc_thread *thr, void *dp, size_t s)
+{
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_alloc;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct = acc_construct_parallel;
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL;
+ data_event_info.data_event.bytes = s;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info, api_info);
+}
+
static void *
nvptx_alloc (size_t s)
{
CUdeviceptr d;
CUDA_CALL_ERET (NULL, cuMemAlloc, &d, s);
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ bool profiling_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ if (profiling_p)
+ goacc_profiling_acc_ev_alloc (thr, (void *) d, s);
+
return (void *) d;
}
+static void
+goacc_profiling_acc_ev_free (struct goacc_thread *thr, void *p)
+{
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+
+ prof_info->event_type = acc_ev_free;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct = acc_construct_parallel;
+ data_event_info.data_event.implicit = 1;
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL;
+ data_event_info.data_event.bytes = -1;
+ data_event_info.data_event.host_ptr = NULL;
+ data_event_info.data_event.device_ptr = p;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info, api_info);
+}
+
static bool
nvptx_free (void *p, struct ptx_device *ptx_dev)
{
@@ -950,6 +1046,12 @@ nvptx_free (void *p, struct ptx_device *ptx_dev)
}
CUDA_CALL (cuMemFree, (CUdeviceptr) p);
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ bool profiling_p
+ = __builtin_expect (thr != NULL && thr->prof_info != NULL, false);
+ if (profiling_p)
+ goacc_profiling_acc_ev_free (thr, p);
+
return true;
}
@@ -1335,6 +1437,12 @@ openacc_exec_internal (void (*fn) (void *), int params, size_t mapnum,
{
GOMP_PLUGIN_debug (0, " %s: prepare mappings\n", __FUNCTION__);
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_p = __builtin_expect (prof_info != NULL, false);
+
void **hp = alloca (mapnum * sizeof (void *));
CUdeviceptr dp = 0;
@@ -1347,17 +1455,50 @@ openacc_exec_internal (void (*fn) (void *), int params, size_t mapnum,
}
else
{
+ size_t s = mapnum * sizeof (void *);
for (int i = 0; i < mapnum; i++)
hp[i] = (devaddrs[i] ? devaddrs[i] : hostaddrs[i]);
- CUDA_CALL_ASSERT (cuMemAlloc, &dp, mapnum * sizeof (void *));
+ CUDA_CALL_ASSERT (cuMemAlloc, &dp, s);
+ if (profiling_p)
+ goacc_profiling_acc_ev_alloc (thr, (void *) dp, s);
}
}
/* Copy the (device) pointers to arguments to the device (dp and hp might in
fact have the same value on a unified-memory system). */
if (!params && mapnum > 0)
- CUDA_CALL_ASSERT (cuMemcpyHtoD, dp, (void *) hp,
- mapnum * sizeof (void *));
+ {
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel;
+ data_event_info.data_event.implicit = 1; /* Always implicit. */
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL;
+ data_event_info.data_event.bytes = mapnum * sizeof (void *);
+ data_event_info.data_event.host_ptr = hp;
+ data_event_info.data_event.device_ptr = (const void *) dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+ CUDA_CALL_ASSERT (cuMemcpyHtoD, dp, (void *) hp,
+ mapnum * sizeof (void *));
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+ }
if (params)
nvptx_exec (fn, mapnum, hostaddrs, devaddrs, dims, targ_mem_desc,
@@ -1378,7 +1519,11 @@ openacc_exec_internal (void (*fn) (void *), int params, size_t mapnum,
GOMP_PLUGIN_fatal ("cuStreamSynchronize error: %s", cuda_error (r));
if (!params)
- CUDA_CALL_ASSERT (cuMemFree, dp);
+ {
+ CUDA_CALL_ASSERT (cuMemFree, dp);
+ if (profiling_p)
+ goacc_profiling_acc_ev_free (thr, (void *) dp);
+ }
}
void
@@ -1415,6 +1560,12 @@ openacc_async_exec_internal (void (*fn) (void *), int params, size_t mapnum,
{
GOMP_PLUGIN_debug (0, " %s: prepare mappings\n", __FUNCTION__);
+ struct goacc_thread *thr = GOMP_PLUGIN_goacc_thread ();
+ acc_prof_info *prof_info = thr->prof_info;
+ acc_event_info data_event_info;
+ acc_api_info *api_info = thr->api_info;
+ bool profiling_p = __builtin_expect (prof_info != NULL, false);
+
void **hp = NULL;
CUdeviceptr dp = 0;
void **block = NULL;
@@ -1429,11 +1580,14 @@ openacc_async_exec_internal (void (*fn) (void *), int params, size_t mapnum,
}
else
{
+ size_t s = mapnum * sizeof (void *);
block = (void **) GOMP_PLUGIN_malloc ((mapnum + 2) * sizeof (void *));
hp = block + 2;
for (int i = 0; i < mapnum; i++)
hp[i] = (devaddrs[i] ? devaddrs[i] : hostaddrs[i]);
- CUDA_CALL_ASSERT (cuMemAlloc, &dp, mapnum * sizeof (void *));
+ CUDA_CALL_ASSERT (cuMemAlloc, &dp, s);
+ if (profiling_p)
+ goacc_profiling_acc_ev_alloc (thr, (void *) dp, s);
}
}
@@ -1441,6 +1595,28 @@ openacc_async_exec_internal (void (*fn) (void *), int params, size_t mapnum,
fact have the same value on a unified-memory system). */
if (!params && mapnum > 0)
{
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_start;
+
+ data_event_info.data_event.event_type = prof_info->event_type;
+ data_event_info.data_event.valid_bytes
+ = _ACC_DATA_EVENT_INFO_VALID_BYTES;
+ data_event_info.data_event.parent_construct
+ = acc_construct_parallel;
+ data_event_info.data_event.implicit = 1; /* Always implicit. */
+ data_event_info.data_event.tool_info = NULL;
+ data_event_info.data_event.var_name = NULL;
+ data_event_info.data_event.bytes = mapnum * sizeof (void *);
+ data_event_info.data_event.host_ptr = hp;
+ data_event_info.data_event.device_ptr = (const void *) dp;
+
+ api_info->device_api = acc_device_api_cuda;
+
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
+
CUDA_CALL_ASSERT (cuMemcpyHtoDAsync, dp, (void *) hp,
mapnum * sizeof (void *), aq->cuda_stream);
block[0] = (void *) dp;
@@ -1448,6 +1624,14 @@ openacc_async_exec_internal (void (*fn) (void *), int params, size_t mapnum,
struct nvptx_thread *nvthd =
(struct nvptx_thread *) GOMP_PLUGIN_acc_thread ();
block[1] = (void *) nvthd->ptx_dev;
+
+ if (profiling_p)
+ {
+ prof_info->event_type = acc_ev_enqueue_upload_end;
+ data_event_info.data_event.event_type = prof_info->event_type;
+ GOMP_PLUGIN_goacc_profiling_dispatch (prof_info, &data_event_info,
+ api_info);
+ }
}
if (params)
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
new file mode 100644
index 0000000..d929bfd
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
@@ -0,0 +1,353 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit 'copyin' clauses, to work around "'firstprivate'
+ optimizations", which will cause the value at the point of call to be used
+ (*before* any potential modifications done in callbacks), as opposed to its
+ address being taken, which then later gets dereferenced (*after* any
+ modifications done in callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int state = -1;
+
+#define STATE_OP(state, op) \
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+static void cb_compute_construct_start_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 10
+ || state == 30
+ || state == 41
+ || state == 51
+ || state == 91
+ || state == 101
+ || state == 151);
+ STATE_OP (state, ++);
+}
+
+static void cb_compute_construct_start_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 11
+ || state == 40
+ || state == 50
+ || state == 90
+ || state == 100
+ || state == 150);
+ STATE_OP (state, ++);
+}
+
+static void cb_compute_construct_end_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 14
+ || state == 21
+ || state == 32
+ || state == 42
+ || state == 80
+ || state == 103
+ || state == 152);
+ STATE_OP (state, ++);
+}
+
+static void cb_compute_construct_end_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 13
+ || state == 43
+ || state == 102
+ || state == 154);
+ STATE_OP (state, ++);
+}
+
+static void cb_compute_construct_end_3 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 12
+ || state == 20
+ || state == 31
+ || state == 44
+ || state == 81
+ || state == 104
+ || state == 153);
+ STATE_OP (state, ++);
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ STATE_OP (state, = 0);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 2);
+ }
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 12);
+ }
+ assert (state == 15);
+
+ STATE_OP (state, = 20);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 20);
+ }
+ assert (state == 20);
+
+ STATE_OP (state, = 30);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 31);
+ }
+ assert (state == 33);
+
+ STATE_OP (state, = 40);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 42);
+ }
+ assert (state == 45);
+
+ STATE_OP (state, = 50);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 52);
+ }
+ assert (state == 52);
+
+ STATE_OP (state, = 60);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 60);
+ }
+ assert (state == 60);
+
+ STATE_OP (state, = 70);
+ unreg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 70);
+ }
+ assert (state == 70);
+
+ STATE_OP (state, = 80);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 80);
+ }
+ assert (state == 82);
+
+ STATE_OP (state, = 90);
+ reg (acc_ev_compute_construct_start, NULL, acc_toggle);
+ unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 92);
+ }
+ assert (state == 92);
+
+ STATE_OP (state, = 100);
+ reg (acc_ev_compute_construct_end, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 102);
+ }
+ assert (state == 105);
+
+ STATE_OP (state, = 110);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 110);
+ }
+ assert (state == 110);
+
+ STATE_OP (state, = 120);
+ unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 120);
+ }
+ assert (state == 120);
+
+ STATE_OP (state, = 130);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 130);
+ }
+ assert (state == 130);
+
+ STATE_OP (state, = 140);
+ unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
+ unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 140);
+ }
+ assert (state == 140);
+
+ STATE_OP (state, = 150);
+ reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+ assert (state_init == 152);
+ }
+ assert (state == 155);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
new file mode 100644
index 0000000..b356feb
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
@@ -0,0 +1,316 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit 'copyin' clauses, to work around "'firstprivate'
+ optimizations", which will cause the value at the point of call to be used
+ (*before* any potential modifications done in callbacks), as opposed to its
+ address being taken, which then later gets dereferenced (*after* any
+ modifications done in callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int state = -1;
+
+#define STATE_OP(state, op) \
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+static void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 1)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+static void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ if (state == 2)
+ assert (prof_info->device_type == acc_device_host);
+ else
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+static void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 10
+ || state == 110);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+}
+
+static void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 11
+ || state == 111);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ assert (state == 0);
+
+ acc_init (acc_device_host);
+ assert (state == 2);
+
+ STATE_OP (state, = 10);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = 12;
+
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 11);
+ }
+ assert (state == 12);
+
+ STATE_OP (state, = 90);
+ acc_shutdown (acc_device_host);
+ assert (state == 90);
+
+
+ STATE_OP (state, = 100);
+ acc_init (acc_device_default);
+ assert (state == 102);
+
+ STATE_OP (state, = 110);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = 12;
+
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 111);
+ }
+ assert (state == 112);
+
+ STATE_OP (state, = 190);
+ acc_shutdown (acc_device_default);
+ assert (state == 190);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
new file mode 100644
index 0000000..7cfc364
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
@@ -0,0 +1,229 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit 'copyin' clauses, to work around "'firstprivate'
+ optimizations", which will cause the value at the point of call to be used
+ (*before* any potential modifications done in callbacks), as opposed to its
+ address being taken, which then later gets dereferenced (*after* any
+ modifications done in callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+/* See the 'DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT' reference in
+ 'libgomp.texi'. */
+#define DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT 0
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+volatile // TODO PR90488
+static int state = -1;
+
+#define STATE_OP(state, op) \
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int num_gangs, num_workers, vector_length;
+
+
+static void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 0);
+ STATE_OP (state, = 1);
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == NULL);
+ assert (event_info->launch_event.kernel_name != NULL);
+ {
+ const char *s = strstr (event_info->launch_event.kernel_name, "main");
+ assert (s != NULL);
+ s = strstr (s, "omp_fn");
+ assert (s != NULL);
+ }
+ if (num_gangs < 1)
+ assert (event_info->launch_event.num_gangs >= 1);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.num_gangs == num_gangs);
+#else
+ /* No parallelized OpenACC 'kernels' constructs. Unparallelized OpenACC
+ 'kernels' constructs must get launched as 1 x 1 x 1 GPU kernels. */
+ assert (event_info->launch_event.num_gangs == 1);
+#endif
+ }
+ if (num_workers < 1)
+ assert (event_info->launch_event.num_workers >= 1);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.num_workers == num_workers);
+#else
+ /* See 'num_gangs' above. */
+ assert (event_info->launch_event.num_workers == 1);
+#endif
+ }
+ if (vector_length < 1)
+ assert (event_info->launch_event.vector_length >= 1);
+ else if (acc_device_type == acc_device_nvidia) /* ... is special. */
+ assert (event_info->launch_event.vector_length == 32);
+ else
+ {
+#ifdef __OPTIMIZE__
+ assert (event_info->launch_event.vector_length == vector_length);
+#else
+ /* See 'num_gangs' above. */
+ assert (event_info->launch_event.vector_length == 1);
+#endif
+ }
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ STATE_OP (state, = 0);
+ reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
+ assert (state == 0);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ assert (state == 0);
+
+ /* Parallelism dimensions: compiler/runtime decides. */
+ STATE_OP (state, = 0);
+ num_gangs = num_workers = vector_length = 0;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No 'acc_ev_enqueue_launch_start'. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ /* Parallelism dimensions: literal. */
+ STATE_OP (state, = 0);
+ num_gangs = 30;
+ num_workers = 3;
+ vector_length = 5;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels \
+ num_gangs (30) num_workers (3) vector_length (5)
+ /* { dg-prune-output "using vector_length \\(32\\), ignoring 5" } */
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No 'acc_ev_enqueue_launch_start'. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ /* Parallelism dimensions: variable. */
+ STATE_OP (state, = 0);
+ num_gangs = 22;
+ num_workers = 5;
+ vector_length = 7;
+ {
+#define N 100
+ int x[N];
+#pragma acc kernels \
+ num_gangs (num_gangs) num_workers (num_workers) vector_length (vector_length)
+ /* { dg-prune-output "using vector_length \\(32\\), ignoring runtime setting" } */
+ {
+ for (int i = 0; i < N; ++i)
+ x[i] = i * i;
+ }
+ if (acc_device_type == acc_device_host)
+ assert (state == 0); /* No 'acc_ev_enqueue_launch_start'. */
+ else
+ assert (state == 1);
+ for (int i = 0; i < N; ++i)
+ if (x[i] != i * i)
+ __builtin_abort ();
+#undef N
+ }
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
new file mode 100644
index 0000000..ac6eb48
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
@@ -0,0 +1,719 @@
+/* Test dispatch of events to callbacks. */
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <acc_prof.h>
+
+
+/* Use explicit 'copyin' clauses, to work around "'firstprivate'
+ optimizations", which will cause the value at the point of call to be used
+ (*before* any potential modifications done in callbacks), as opposed to its
+ address being taken, which then later gets dereferenced (*after* any
+ modifications done in callbacks). */
+#define COPYIN(...) copyin(__VA_ARGS__)
+
+
+/* See the 'DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT' reference in
+ libgomp.texi. */
+#define DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT 0
+
+
+/* Do we expect to see 'acc_ev_exit_data_start' and 'acc_ev_exit_data_end'
+ after a compute construct with an 'async' clause? */
+#define ASYNC_EXIT_DATA 1
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int state = -1;
+
+#define STATE_OP(state, op) \
+ do \
+ { \
+ typeof (state) state_o = (state); \
+ (void) state_o; \
+ (state)op; \
+ DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
+ } \
+ while (0)
+
+
+static acc_device_t acc_device_type;
+static int acc_device_num;
+static int acc_async;
+
+
+struct tool_info
+{
+ acc_event_info event_info;
+ struct tool_info *nested;
+};
+struct tool_info *tool_info;
+
+static void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+#else
+ assert (state == 0
+ || state == 100);
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+#else
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+#endif
+}
+
+static void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 2
+ || state == 102);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_device_init_start);
+#else
+ assert (state == 1
+ || state == 101);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
+#endif
+
+ assert (prof_info->event_type == acc_ev_device_init_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_default);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (event_info->other_event.tool_info == tool_info->nested);
+#else
+ assert (event_info->other_event.tool_info == tool_info);
+#endif
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+#else
+ free (tool_info);
+ tool_info = NULL;
+#endif
+}
+
+static void cb_enter_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 3
+ || state == 103);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enter_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+static void cb_enter_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 4
+ || state == 104);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_enter_data_start);
+
+ assert (prof_info->event_type == acc_ev_enter_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+static void cb_exit_data_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 7
+#if ASYNC_EXIT_DATA
+ || state == 107
+#endif
+ );
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_exit_data_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == NULL);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+static void cb_exit_data_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (state == 8
+#if ASYNC_EXIT_DATA
+ || state == 108
+#endif
+ );
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.other_event.event_type == acc_ev_exit_data_start);
+
+ assert (prof_info->event_type == acc_ev_exit_data_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 1);
+ assert (event_info->other_event.tool_info == tool_info->nested);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+static void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+#if DEVICE_INIT_INSIDE_COMPUTE_CONSTRUCT
+ assert (state == 0
+ || state == 100);
+ if (state == 100)
+ {
+ /* Compensate for the missing 'acc_ev_device_init_start' and
+ 'acc_ev_device_init_end'. */
+ state += 2;
+ }
+#else
+ if (state == 100)
+ {
+ /* Compensate for the missing 'acc_ev_device_init_start' and
+ 'acc_ev_device_init_end'. */
+ state += 2;
+ }
+ assert (state == 2
+ || state == 102);
+#endif
+ STATE_OP (state, ++);
+
+ assert (tool_info == NULL);
+ tool_info = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info != NULL);
+ tool_info->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_compute_construct_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == NULL);
+
+ assert (api_info->device_api == acc_device_api_none);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
+ event_info->other_event.tool_info = tool_info;
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing 'acc_ev_enter_data_start'. */
+ state += 1;
+ }
+}
+
+static void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ if (acc_device_type == acc_device_host)
+ {
+ /* Compensate for the missing 'acc_ev_enter_data_end'. */
+ state += 1;
+ /* Compensate for the missing 'acc_ev_enqueue_launch_start' and
+ 'acc_ev_enqueue_launch_end'. */
+ state += 2;
+ /* Compensate for the missing 'acc_ev_exit_data_start' and
+ 'acc_ev_exit_data_end'. */
+ state += 2;
+ }
+#if !ASYNC_EXIT_DATA
+ else if (acc_async != acc_async_sync)
+ {
+ /* Compensate for the missing 'acc_ev_exit_data_start' and
+ 'acc_ev_exit_data_end'. */
+ state += 2;
+ }
+#endif
+ assert (state == 9
+ || state == 109);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+
+ assert (prof_info->event_type == acc_ev_compute_construct_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ if (acc_device_type == acc_device_host)
+ assert (prof_info->async == acc_async_sync);
+ else
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->other_event.event_type == prof_info->event_type);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (event_info->other_event.parent_construct == acc_construct_parallel);
+ assert (event_info->other_event.implicit == 0);
+ assert (event_info->other_event.tool_info == tool_info);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free (tool_info);
+ tool_info = NULL;
+}
+
+static void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 5
+ || state == 105);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested == NULL);
+ tool_info->nested = (struct tool_info *) malloc(sizeof *tool_info);
+ assert (tool_info->nested != NULL);
+ tool_info->nested->nested = NULL;
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_start);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == NULL);
+ assert (event_info->launch_event.kernel_name != NULL);
+ {
+ const char *s = strstr (event_info->launch_event.kernel_name, "main");
+ assert (s != NULL);
+ s = strstr (s, "omp_fn");
+ assert (s != NULL);
+ }
+ assert (event_info->launch_event.num_gangs >= 1);
+ assert (event_info->launch_event.num_workers >= 1);
+ assert (event_info->launch_event.vector_length >= 1);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ tool_info->nested->event_info.launch_event.event_type = event_info->launch_event.event_type;
+ tool_info->nested->event_info.launch_event.kernel_name = strdup (event_info->launch_event.kernel_name);
+ tool_info->nested->event_info.launch_event.num_gangs = event_info->launch_event.num_gangs;
+ tool_info->nested->event_info.launch_event.num_workers = event_info->launch_event.num_workers;
+ tool_info->nested->event_info.launch_event.vector_length = event_info->launch_event.vector_length;
+ event_info->other_event.tool_info = tool_info->nested;
+}
+
+static void cb_enqueue_launch_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ assert (acc_device_type != acc_device_host);
+
+ assert (state == 6
+ || state == 106);
+ STATE_OP (state, ++);
+
+ assert (tool_info != NULL);
+ assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
+ assert (tool_info->nested != NULL);
+ assert (tool_info->nested->event_info.launch_event.event_type == acc_ev_enqueue_launch_start);
+ assert (tool_info->nested->event_info.launch_event.kernel_name != NULL);
+ assert (tool_info->nested->event_info.launch_event.num_gangs >= 1);
+ assert (tool_info->nested->event_info.launch_event.num_workers >= 1);
+ assert (tool_info->nested->event_info.launch_event.vector_length >= 1);
+
+ assert (prof_info->event_type == acc_ev_enqueue_launch_end);
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (prof_info->version == _ACC_PROF_INFO_VERSION);
+ assert (prof_info->device_type == acc_device_type);
+ assert (prof_info->device_number == acc_device_num);
+ assert (prof_info->thread_id == -1);
+ assert (prof_info->async == acc_async);
+ assert (prof_info->async_queue == prof_info->async);
+ assert (prof_info->src_file == NULL);
+ assert (prof_info->func_name == NULL);
+ assert (prof_info->line_no == -1);
+ assert (prof_info->end_line_no == -1);
+ assert (prof_info->func_line_no == -1);
+ assert (prof_info->func_end_line_no == -1);
+
+ assert (event_info->launch_event.event_type == prof_info->event_type);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (event_info->launch_event.parent_construct == acc_construct_parallel);
+ assert (event_info->launch_event.implicit == 1);
+ assert (event_info->launch_event.tool_info == tool_info->nested);
+ assert (event_info->launch_event.kernel_name != NULL);
+ assert (strcmp (event_info->launch_event.kernel_name, tool_info->nested->event_info.launch_event.kernel_name) == 0);
+ assert (event_info->launch_event.num_gangs == tool_info->nested->event_info.launch_event.num_gangs);
+ assert (event_info->launch_event.num_workers == tool_info->nested->event_info.launch_event.num_workers);
+ assert (event_info->launch_event.vector_length == tool_info->nested->event_info.launch_event.vector_length);
+
+ if (acc_device_type == acc_device_host)
+ assert (api_info->device_api == acc_device_api_none);
+ else
+ assert (api_info->device_api == acc_device_api_cuda);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+ assert (api_info->device_type == prof_info->device_type);
+ assert (api_info->vendor == -1);
+ assert (api_info->device_handle == NULL);
+ assert (api_info->context_handle == NULL);
+ assert (api_info->async_handle == NULL);
+
+ free ((void *) tool_info->nested->event_info.launch_event.kernel_name);
+ free (tool_info->nested);
+ tool_info->nested = NULL;
+}
+
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ STATE_OP (state, = 0);
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+ reg (acc_ev_enter_data_start, cb_enter_data_start, acc_reg);
+ reg (acc_ev_enter_data_end, cb_enter_data_end, acc_reg);
+ reg (acc_ev_exit_data_start, cb_exit_data_start, acc_reg);
+ reg (acc_ev_exit_data_end, cb_exit_data_end, acc_reg);
+ reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
+ reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
+ reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
+ reg (acc_ev_enqueue_launch_end, cb_enqueue_launch_end, acc_reg);
+ assert (state == 0);
+
+ acc_device_type = acc_get_device_type ();
+ acc_device_num = acc_get_device_num (acc_device_type);
+ acc_async = acc_async_sync;
+ assert (state == 0);
+
+ {
+ int state_init;
+#pragma acc parallel COPYIN(state) copyout(state_init)
+ {
+ asm volatile ("" : : : "memory"); // TODO PR90488
+
+ state_init = state;
+ }
+ assert (state_init == 4);
+ }
+ assert (state == 10);
+
+ STATE_OP (state, = 100);
+
+ acc_async = 12;
+ {
+ int state_init;
+#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
+ {
+ asm volatile ("" : : : "memory"); // TODO PR90488
+
+ state_init = state;
+ }
+#pragma acc wait
+ assert (state_init == 104);
+ }
+ assert (state == 110);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
new file mode 100644
index 0000000..5b58c51
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
@@ -0,0 +1,226 @@
+/* Test the 'valid_bytes' magic. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int ev_count_data;
+
+static void cb_data_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->data_event.valid_bytes == _ACC_DATA_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+
+ ++ev_count_data;
+}
+
+static int ev_count_launch;
+
+static void cb_launch_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->launch_event.valid_bytes == _ACC_LAUNCH_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+
+ ++ev_count_launch;
+}
+
+static int ev_count_other;
+
+static void cb_other_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
+ assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
+ assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
+
+ ++ev_count_other;
+}
+
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_other_event, acc_reg);
+ reg_ (acc_ev_create, cb_data_event, acc_reg);
+ reg_ (acc_ev_delete, cb_data_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_data_event, acc_reg);
+ reg_ (acc_ev_free, cb_data_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_other_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_launch_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_data_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_data_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_other_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_other_event, acc_reg);
+}
+
+
+/* Basic struct. */
+typedef struct A
+{
+ int a;
+ int b;
+#define VALID_BYTES_A \
+ _ACC_PROF_VALID_BYTES_STRUCT (A, b, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (int))
+} A;
+
+/* Add a 'char' field. */
+typedef struct B
+{
+ int a;
+ int b;
+ char c;
+#define VALID_BYTES_B \
+ _ACC_PROF_VALID_BYTES_STRUCT (B, c, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} B;
+
+/* Add another 'char' field. */
+typedef struct C
+{
+ int a;
+ int b;
+ char c, d;
+#define VALID_BYTES_C \
+ _ACC_PROF_VALID_BYTES_STRUCT (C, d, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} C;
+
+/* Add two 'void *' fields. */
+typedef struct D
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+#define VALID_BYTES_D \
+ _ACC_PROF_VALID_BYTES_STRUCT (D, f, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
+} D;
+
+/* Add another three 'char' fields. */
+typedef struct E
+{
+ int a;
+ int b;
+ char c, d;
+ void *e;
+ void *f;
+ char g, h, i;
+#define VALID_BYTES_E \
+ _ACC_PROF_VALID_BYTES_STRUCT (E, i, \
+ _ACC_PROF_VALID_BYTES_BASICTYPE (char))
+} E;
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ A A1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof A1, VALID_BYTES_A);
+ assert (VALID_BYTES_A <= sizeof A1);
+ DEBUG_printf ("&A1=%p, &A1.b=%p\n", &A1, &A1.b);
+ assert (((char *) &A1) + VALID_BYTES_A == (char *) (&A1.b + 1));
+
+ B B1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof B1, VALID_BYTES_B);
+ assert (VALID_BYTES_B <= sizeof B1);
+ DEBUG_printf ("&B1=%p, &B1.c=%p\n", &B1, &B1.c);
+ assert (((char *) &B1) + VALID_BYTES_B == (char *) (&B1.c + 1));
+
+ assert (VALID_BYTES_B == VALID_BYTES_A + 1 * sizeof (char));
+
+ C C1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof C1, VALID_BYTES_C);
+ assert (VALID_BYTES_C <= sizeof C1);
+ DEBUG_printf ("&C1=%p, &C1.d=%p\n", &C1, &C1.d);
+ assert (((char *) &C1) + VALID_BYTES_C == (char *) (&C1.d + 1));
+
+ assert (VALID_BYTES_C == VALID_BYTES_B + 1 * sizeof (char));
+
+ D D1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof D1, VALID_BYTES_D);
+ assert (VALID_BYTES_D <= sizeof D1);
+ DEBUG_printf ("&D1=%p, &D1.f=%p\n", &D1, &D1.f);
+ assert (((char *) &D1) + VALID_BYTES_D == (char *) (&D1.f + 1));
+
+ assert (VALID_BYTES_D > VALID_BYTES_C);
+
+ E E1;
+ DEBUG_printf ("s=%zd, vb=%zd\n", sizeof E1, VALID_BYTES_E);
+ assert (VALID_BYTES_E <= sizeof E1);
+ DEBUG_printf ("&E1=%p, &E1.i=%p\n", &E1, &E1.i);
+ assert (((char *) &E1) + VALID_BYTES_E == (char *) (&E1.i + 1));
+
+ assert (VALID_BYTES_E == VALID_BYTES_D + 3 * sizeof (char));
+
+ ev_count_data = 0;
+ ev_count_launch = 0;
+ ev_count_other = 0;
+
+ /* Trigger tests done in 'cb_*' functions. */
+ int host;
+#pragma acc parallel copyout (host)
+ {
+ asm volatile ("" : : : "memory"); // TODO PR90488
+
+ host = acc_on_device (acc_device_host);
+ }
+
+ DEBUG_printf ("ev_count_data = %d\n", ev_count_data);
+ if (host)
+ assert (ev_count_data == 0);
+ else
+ {
+ /* We don't know exactly how many data events to expect, but we at least
+ expect some. */
+ assert (ev_count_data > 0);
+ }
+
+ DEBUG_printf ("ev_count_launch = %d\n", ev_count_launch);
+ if (host)
+ assert (ev_count_data == 0);
+ else
+ {
+ /* We expect two launch events, 'acc_ev_enqueue_launch_start',
+ 'acc_ev_enqueue_launch_end'. */
+ assert (ev_count_launch == 2);
+ }
+
+ DEBUG_printf ("ev_count_other = %d\n", ev_count_other);
+ /* We don't know exactly how many other events to expect, but we at least
+ expect 'acc_ev_device_init_start', 'acc_ev_device_init_end',
+ 'acc_ev_compute_construct_start', 'acc_ev_compute_construct_end'. */
+ assert (ev_count_other >= 4);
+
+ return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
new file mode 100644
index 0000000..f537868
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-version-1.c
@@ -0,0 +1,76 @@
+/* Test the 'version' field of 'acc_prof_info'. */
+
+#undef NDEBUG
+#include <assert.h>
+
+#include <acc_prof.h>
+
+
+#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+
+
+static int ev_count;
+
+
+static void cb_any_event (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ DEBUG_printf ("%s %d\n", __FUNCTION__, prof_info->event_type);
+
+ assert (prof_info->version == 201711);
+
+ ++ev_count;
+}
+
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg_ (acc_ev_device_init_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_init_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_device_shutdown_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_runtime_shutdown, cb_any_event, acc_reg);
+ reg_ (acc_ev_create, cb_any_event, acc_reg);
+ reg_ (acc_ev_delete, cb_any_event, acc_reg);
+ reg_ (acc_ev_alloc, cb_any_event, acc_reg);
+ reg_ (acc_ev_free, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enter_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_exit_data_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_update_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_compute_construct_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_launch_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_upload_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_enqueue_download_end, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_start, cb_any_event, acc_reg);
+ reg_ (acc_ev_wait_end, cb_any_event, acc_reg);
+}
+
+
+int main()
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ ev_count = 0;
+
+ /* Trigger tests done in 'cb_*' functions. */
+#pragma acc parallel
+ {
+ asm volatile ("" : : : "memory"); // TODO PR90488
+ }
+
+ DEBUG_printf ("ev_count = %d\n", ev_count);
+ /* We don't know exactly how many events to expect, but we at least expect
+ 'acc_ev_device_init_start', 'acc_ev_device_init_end',
+ 'acc_ev_compute_construct_start', 'acc_ev_compute_construct_end'. */
+ assert (ev_count >= 4);
+
+ return 0;
+}
--
2.8.1
[-- Attachment #3: 0002-Add-changes-to-profiling-interface-from-OG8-branch.patch --]
[-- Type: text/plain, Size: 22200 bytes --]
From 341285e282f5b7ed73daaeb9fd2f820dc1fe91f9 Mon Sep 17 00:00:00 2001
From: Kwok Cheung Yeung <kcy@codesourcery.com>
Date: Fri, 21 Jun 2019 10:40:38 -0700
Subject: [PATCH 2/2] Add changes to profiling interface from OG8 branch
This bundles up the parts of the profiling code from the OG8 branch that were
not included in the upstream patch.
libgomp/
* testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c: Update.
libgomp/
* oacc-init.c (get_property_any): Add profiling code.
libgomp/
* Makefile.am (libgomp_la_SOURCES): Add
oacc-profiling-acc_register_library.c.
* Makefile.in: Regenerate.
* libgomp.texi: Remove paragraph about acc_register_library.
* oacc-parallel.c (GOACC_parallel_keyed_internal): Set device_api for
profiling.
* oacc-profiling-acc_register_library.c: New file.
* oacc-profiling.c (goacc_profiling_initialize): Call
acc_register_library. Avoid duplicate registration.
(acc_register_library): Remove.
* config/nvptx/oacc-profiling-acc_register_library.c:
New empty file.
* config/nvptx/oacc-profiling.c: Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c: Remove
call to acc_register_library.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c: Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c:
Likewise.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c: Remove
call to acc_register_library. Add mis-optimization workaround.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c: Likewise.
---
libgomp/ChangeLog.openacc | 32 +++++++++++++++
libgomp/Makefile.am | 3 +-
libgomp/Makefile.in | 11 ++++--
.../nvptx/oacc-profiling-acc_register_library.c | 0
libgomp/config/nvptx/oacc-profiling.c | 0
libgomp/libgomp.texi | 8 ----
libgomp/oacc-init.c | 22 +++++++++++
libgomp/oacc-parallel.c | 2 +
libgomp/oacc-profiling-acc_register_library.c | 39 ++++++++++++++++++
libgomp/oacc-profiling.c | 32 +++++++++------
.../acc_prof-dispatch-1.c | 2 -
.../libgomp.oacc-c-c++-common/acc_prof-init-1.c | 2 -
.../libgomp.oacc-c-c++-common/acc_prof-kernels-1.c | 46 +++++++++++++++++++---
.../acc_prof-parallel-1.c | 11 +++++-
.../acc_prof-valid_bytes-1.c | 2 -
15 files changed, 173 insertions(+), 39 deletions(-)
create mode 100644 libgomp/config/nvptx/oacc-profiling-acc_register_library.c
create mode 100644 libgomp/config/nvptx/oacc-profiling.c
create mode 100644 libgomp/oacc-profiling-acc_register_library.c
diff --git a/libgomp/ChangeLog.openacc b/libgomp/ChangeLog.openacc
index 04c7778..4d4264b 100644
--- a/libgomp/ChangeLog.openacc
+++ b/libgomp/ChangeLog.openacc
@@ -1,3 +1,35 @@
+2019-01-23 Thomas Schwinge <thomas@codesourcery.com>
+
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c: Update.
+
+2018-12-20 Maciej W. Rozycki <macro@codesourcery.com>
+
+ * oacc-init.c (get_property_any): Add profiling code.
+
+2017-02-28 Thomas Schwinge <thomas@codesourcery.com>
+
+ * Makefile.am (libgomp_la_SOURCES): Add
+ oacc-profiling-acc_register_library.c.
+ * Makefile.in: Regenerate.
+ * libgomp.texi: Remove paragraph about acc_register_library.
+ * oacc-parallel.c (GOACC_parallel_keyed_internal): Set device_api for
+ profiling.
+ * oacc-profiling-acc_register_library.c: New file.
+ * oacc-profiling.c (goacc_profiling_initialize): Call
+ acc_register_library. Avoid duplicate registration.
+ (acc_register_library): Remove.
+ * config/nvptx/oacc-profiling-acc_register_library.c:
+ New empty file.
+ * config/nvptx/oacc-profiling.c: Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c: Remove
+ call to acc_register_library.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c: Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c:
+ Likewise.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c: Remove
+ call to acc_register_library. Add mis-optimization workaround.
+ * testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c: Likewise.
+
2019-05-17 Thomas Schwinge <thomas@codesourcery.com>
* acc_prof.h: New file.
diff --git a/libgomp/Makefile.am b/libgomp/Makefile.am
index 5091870..00848cd 100644
--- a/libgomp/Makefile.am
+++ b/libgomp/Makefile.am
@@ -72,7 +72,8 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c error.c \
proc.c sem.c bar.c ptrlock.c time.c fortran.c affinity.c target.c \
splay-tree.c libgomp-plugin.c oacc-parallel.c oacc-host.c oacc-init.c \
oacc-mem.c oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
- affinity-fmt.c teams.c oacc-profiling.c
+ affinity-fmt.c teams.c oacc-profiling.c \
+ oacc-profiling-acc_register_library.c
include $(top_srcdir)/plugin/Makefrag.am
diff --git a/libgomp/Makefile.in b/libgomp/Makefile.in
index 23efc84..63f919c 100644
--- a/libgomp/Makefile.in
+++ b/libgomp/Makefile.in
@@ -16,7 +16,7 @@
# Plugins for offload execution, Makefile.am fragment.
#
-# Copyright (C) 2014-2018 Free Software Foundation, Inc.
+# Copyright (C) 2014-2019 Free Software Foundation, Inc.
#
# Contributed by Mentor Embedded.
#
@@ -216,7 +216,8 @@ am_libgomp_la_OBJECTS = alloc.lo atomic.lo barrier.lo critical.lo \
target.lo splay-tree.lo libgomp-plugin.lo oacc-parallel.lo \
oacc-host.lo oacc-init.lo oacc-mem.lo oacc-async.lo \
oacc-plugin.lo oacc-cuda.lo priority_queue.lo affinity-fmt.lo \
- teams.lo oacc-profiling.lo $(am__objects_1)
+ teams.lo oacc-profiling.lo \
+ oacc-profiling-acc_register_library.lo $(am__objects_1)
libgomp_la_OBJECTS = $(am_libgomp_la_OBJECTS)
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
@@ -524,7 +525,7 @@ search_path = $(addprefix $(top_srcdir)/config/, $(config_path)) $(top_srcdir) \
fincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)$(MULTISUBDIR)/finclude
libsubincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)/include
-libgomp_la_LIBADD = $(LIBFFI)
+@USE_LIBFFI_TRUE@libgomp_la_LIBADD = $(LIBFFI)
AM_CPPFLAGS = $(addprefix -I, $(search_path)) $(LIBFFIINCS)
AM_CFLAGS = $(XCFLAGS)
AM_LDFLAGS = $(XLDFLAGS) $(SECTION_LDFLAGS) $(OPT_LDFLAGS)
@@ -553,7 +554,8 @@ libgomp_la_SOURCES = alloc.c atomic.c barrier.c critical.c env.c \
affinity.c target.c splay-tree.c libgomp-plugin.c \
oacc-parallel.c oacc-host.c oacc-init.c oacc-mem.c \
oacc-async.c oacc-plugin.c oacc-cuda.c priority_queue.c \
- affinity-fmt.c teams.c oacc-profiling.c $(am__append_3)
+ affinity-fmt.c teams.c oacc-profiling.c \
+ oacc-profiling-acc_register_library.c $(am__append_3)
# Nvidia PTX OpenACC plugin.
@PLUGIN_NVPTX_TRUE@libgomp_plugin_nvptx_version_info = -version-info $(libtool_VERSION)
@@ -755,6 +757,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-mem.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-parallel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-plugin.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-profiling-acc_register_library.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oacc-profiling.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ordered.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/parallel.Plo@am__quote@
diff --git a/libgomp/config/nvptx/oacc-profiling-acc_register_library.c b/libgomp/config/nvptx/oacc-profiling-acc_register_library.c
new file mode 100644
index 0000000..e69de29
diff --git a/libgomp/config/nvptx/oacc-profiling.c b/libgomp/config/nvptx/oacc-profiling.c
new file mode 100644
index 0000000..e69de29
diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi
index 2e05272..5c9cf9e 100644
--- a/libgomp/libgomp.texi
+++ b/libgomp/libgomp.texi
@@ -3254,14 +3254,6 @@ every event that has been registered.
We're not yet accounting for the fact that @cite{OpenACC events may
occur during event processing}.
-We're not yet implementing initialization via a
-@code{acc_register_library} function that is either statically linked
-in, or dynamically via @env{LD_PRELOAD}.
-Initialization via @code{acc_register_library} functions dynamically
-loaded via the @env{ACC_PROFLIB} environment variable does work, as
-does directly calling @code{acc_prof_register},
-@code{acc_prof_unregister}, @code{acc_prof_lookup}.
-
As currently there are no inquiry functions defined, calls to
@code{acc_prof_lookup} will always return @code{NULL}.
diff --git a/libgomp/oacc-init.c b/libgomp/oacc-init.c
index f7ea58f..766f59f 100644
--- a/libgomp/oacc-init.c
+++ b/libgomp/oacc-init.c
@@ -791,14 +791,30 @@ get_property_any (int ord, acc_device_t d, acc_device_property_t prop)
if (d == acc_device_current && (!thr || !thr->dev))
return (union gomp_device_property_value) { .val = 0 };
+ acc_prof_info prof_info;
+ acc_api_info api_info;
+ bool profiling_p = GOACC_PROFILING_SETUP_P (thr, &prof_info, &api_info);
+
if (d == acc_device_current)
{
+ if (profiling_p)
+ {
+ prof_info.device_type = acc_device_type (thr->dev->type);
+ prof_info.device_number = thr->dev->target_id;
+ }
+
dev = thr->dev;
}
else
{
int num_devices;
+ if (profiling_p)
+ {
+ prof_info.device_type = d;
+ prof_info.device_number = ord;
+ }
+
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (d, false);
@@ -822,6 +838,12 @@ get_property_any (int ord, acc_device_t d, acc_device_property_t prop)
propval = dev->get_property_func (dev->target_id, prop);
+ if (profiling_p)
+ {
+ thr->prof_info = NULL;
+ thr->api_info = NULL;
+ }
+
return propval;
}
diff --git a/libgomp/oacc-parallel.c b/libgomp/oacc-parallel.c
index c798578..9fc0536 100644
--- a/libgomp/oacc-parallel.c
+++ b/libgomp/oacc-parallel.c
@@ -275,6 +275,8 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
goacc_call_host_fn (fn, mapnum, hostaddrs, params);
goto out_prof;
}
+ else if (profiling_p)
+ api_info.device_api = acc_device_api_cuda;
/* Default: let the runtime choose. */
for (i = 0; i != GOMP_DIM_MAX; i++)
diff --git a/libgomp/oacc-profiling-acc_register_library.c b/libgomp/oacc-profiling-acc_register_library.c
new file mode 100644
index 0000000..f6b482b
--- /dev/null
+++ b/libgomp/oacc-profiling-acc_register_library.c
@@ -0,0 +1,39 @@
+/* Copyright (C) 2017 Free Software Foundation, Inc.
+
+ Contributed by Mentor Embedded.
+
+ This file is part of the GNU Offloading and Multi Processing Library
+ (libgomp).
+
+ Libgomp is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
+
+/* This file provides an stub acc_register_library function. It's in a
+ separate file so that this function can easily be overridden when linking
+ statically. */
+
+#include "libgomp.h"
+#include "acc_prof.h"
+
+void
+acc_register_library (acc_prof_reg reg, acc_prof_reg unreg,
+ acc_prof_lookup_func lookup)
+{
+ gomp_debug (0, "dummy %s\n", __FUNCTION__);
+}
diff --git a/libgomp/oacc-profiling.c b/libgomp/oacc-profiling.c
index eff2886..d54f4b8 100644
--- a/libgomp/oacc-profiling.c
+++ b/libgomp/oacc-profiling.c
@@ -104,7 +104,12 @@ goacc_profiling_initialize (void)
for (int i = 0; i < acc_ev_last; ++i)
goacc_prof_callbacks_enabled[i] = true;
-
+ /* We are to invoke an external acc_register_library routine, defaulting to
+ our stub oacc-profiling-acc_register_library.c:acc_register_library
+ implementation. */
+ gomp_debug (0, "%s: calling acc_register_library\n", __FUNCTION__);
+ //TODO.
+ acc_register_library (acc_prof_register, acc_prof_unregister, NULL);
#ifdef PLUGIN_SUPPORT
char *acc_proflibs = secure_getenv ("ACC_PROFLIB");
while (acc_proflibs != NULL && acc_proflibs[0] != '\0')
@@ -141,10 +146,20 @@ goacc_profiling_initialize (void)
= dlsym (dl_handle, "acc_register_library");
if (a_r_l == NULL)
goto dl_fail;
- gomp_debug (0, " %s: calling %s:acc_register_library\n",
- __FUNCTION__, acc_proflib);
- a_r_l (acc_prof_register, acc_prof_unregister,
- acc_prof_lookup);
+ /* Avoid duplicate registration, for example if the same shared
+ library is specified in LD_PRELOAD and ACC_PROFLIB -- which
+ TAU 2.26 does when using "tau_exec -openacc". */
+ if (a_r_l != acc_register_library)
+ {
+ gomp_debug (0, " %s: calling %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
+ //TODO.
+ a_r_l (acc_prof_register, acc_prof_unregister, NULL);
+ }
+ else
+ gomp_debug (0, " %s: skipping duplicate"
+ " %s:acc_register_library\n",
+ __FUNCTION__, acc_proflib);
}
else
{
@@ -487,13 +502,6 @@ acc_prof_lookup (const char *name)
return NULL;
}
-void
-acc_register_library (acc_prof_reg reg, acc_prof_reg unreg,
- acc_prof_lookup_func lookup)
-{
- gomp_fatal ("TODO");
-}
-
/* Prepare to dispatch events? */
bool
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
index d929bfd..a9a8c74 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c
@@ -114,8 +114,6 @@ void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_look
int main()
{
- acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
-
STATE_OP (state, = 0);
reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
index b356feb..6a44e8f 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
@@ -253,8 +253,6 @@ void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_look
int main()
{
- acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
-
STATE_OP (state, = 0);
reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
index 7cfc364..163b7ac 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
@@ -41,6 +41,7 @@ static int state = -1;
static acc_device_t acc_device_type;
static int acc_device_num;
static int num_gangs, num_workers, vector_length;
+static int async;
static void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
@@ -58,7 +59,7 @@ static void cb_enqueue_launch_start (acc_prof_info *prof_info, acc_event_info *e
assert (prof_info->device_type == acc_device_type);
assert (prof_info->device_number == acc_device_num);
assert (prof_info->thread_id == -1);
- assert (prof_info->async == acc_async_sync);
+ assert (prof_info->async == async);
assert (prof_info->async_queue == prof_info->async);
assert (prof_info->src_file == NULL);
assert (prof_info->func_name == NULL);
@@ -144,8 +145,6 @@ void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_look
int main()
{
- acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
-
STATE_OP (state, = 0);
reg (acc_ev_enqueue_launch_start, cb_enqueue_launch_start, acc_reg);
assert (state == 0);
@@ -154,8 +153,10 @@ int main()
acc_device_num = acc_get_device_num (acc_device_type);
assert (state == 0);
- /* Parallelism dimensions: compiler/runtime decides. */
STATE_OP (state, = 0);
+ /* Implicit async. */
+ async = acc_async_noval;
+ /* Parallelism dimensions: compiler/runtime decides. */
num_gangs = num_workers = vector_length = 0;
{
#define N 100
@@ -165,6 +166,15 @@ int main()
for (int i = 0; i < N; ++i)
x[i] = i * i;
}
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
if (acc_device_type == acc_device_host)
assert (state == 0); /* No 'acc_ev_enqueue_launch_start'. */
else
@@ -175,8 +185,10 @@ int main()
#undef N
}
- /* Parallelism dimensions: literal. */
STATE_OP (state, = 0);
+ /* Explicit async: without argument. */
+ async = acc_async_noval;
+ /* Parallelism dimensions: literal. */
num_gangs = 30;
num_workers = 3;
vector_length = 5;
@@ -184,12 +196,22 @@ int main()
#define N 100
int x[N];
#pragma acc kernels \
+ async \
num_gangs (30) num_workers (3) vector_length (5)
/* { dg-prune-output "using vector_length \\(32\\), ignoring 5" } */
{
for (int i = 0; i < N; ++i)
x[i] = i * i;
}
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
if (acc_device_type == acc_device_host)
assert (state == 0); /* No 'acc_ev_enqueue_launch_start'. */
else
@@ -200,8 +222,10 @@ int main()
#undef N
}
- /* Parallelism dimensions: variable. */
STATE_OP (state, = 0);
+ /* Explicit async: variable. */
+ async = 123;
+ /* Parallelism dimensions: variable. */
num_gangs = 22;
num_workers = 5;
vector_length = 7;
@@ -209,12 +233,22 @@ int main()
#define N 100
int x[N];
#pragma acc kernels \
+ async (async) \
num_gangs (num_gangs) num_workers (num_workers) vector_length (vector_length)
/* { dg-prune-output "using vector_length \\(32\\), ignoring runtime setting" } */
{
for (int i = 0; i < N; ++i)
x[i] = i * i;
}
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
if (acc_device_type == acc_device_host)
assert (state == 0); /* No 'acc_ev_enqueue_launch_start'. */
else
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
index ac6eb48..1778928 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
@@ -667,8 +667,6 @@ void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_look
int main()
{
- acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
-
STATE_OP (state, = 0);
reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
@@ -697,6 +695,15 @@ int main()
}
assert (state_init == 4);
}
+#ifdef __OPTIMIZE__
+ /* TODO. With -O2 optimizations enabled, the compiler believes that here
+ "state == 0" still holds. It's not yet clear what's going on.
+ Mis-optimization across the GOMP function call boundary? Per its
+ gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
+ "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
+ must expect calls back into this compilation unit? */
+ asm volatile ("" : : : "memory");
+#endif
assert (state == 10);
STATE_OP (state, = 100);
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
index 5b58c51..a723ad9 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-valid_bytes-1.c
@@ -143,8 +143,6 @@ typedef struct E
int main()
{
- acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
-
A A1;
DEBUG_printf ("s=%zd, vb=%zd\n", sizeof A1, VALID_BYTES_A);
assert (VALID_BYTES_A <= sizeof A1);
--
2.8.1
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH, og9] Port OpenACC profiling interface to OG9
2019-06-24 19:37 ` Kwok Cheung Yeung
@ 2019-07-24 11:05 ` Thomas Schwinge
2019-07-27 5:26 ` Kwok Cheung Yeung
0 siblings, 1 reply; 23+ messages in thread
From: Thomas Schwinge @ 2019-07-24 11:05 UTC (permalink / raw)
To: Kwok Cheung Yeung; +Cc: Catherine Moore, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 6713 bytes --]
Hi Kwok!
On 2019-06-24T20:37:12+0100, Kwok Cheung Yeung <kcy@codesourcery.com> wrote:
> On 17/06/2019 6:24 pm, Thomas Schwinge wrote:
>>> Okay to push to openacc-gcc-9-branch?
>> I think what would be best, is the following approach: [...]
> I have now ported over the mainline patch over to OG9, plus an
> additional patch on top of that to bring in the bits from OG8 that did
> not make it upstream.
>
> I have dropped the differences in comments, TODOs, documentation etc. in
> favour of the upstream patch. There are also various places where the
> OG8 patch sets up profiling, then gotos the end of the function to tear
> it down again, whereas the mainline version just aborts early without
> setting up profiling in the first place - these I have also resolved in
> favour of the mainline version.
ACK, thanks!
> I have rerun the libgomp testsuite with no regressions noted.
(I didn't actually test, but just reviewed the code changes.)
> Okay to push to openacc-gcc-9-branch?
Yes, please push after re-testing with minor modifications in the second
commit, as follows:
> From 341285e282f5b7ed73daaeb9fd2f820dc1fe91f9 Mon Sep 17 00:00:00 2001
> From: Kwok Cheung Yeung <kcy@codesourcery.com>
> Date: Fri, 21 Jun 2019 10:40:38 -0700
> Subject: [PATCH 2/2] Add changes to profiling interface from OG8 branch
>
> This bundles up the parts of the profiling code from the OG8 branch that were
> not included in the upstream patch.
> +2017-02-28 Thomas Schwinge <thomas@codesourcery.com>
> +
> + [...]
> + * oacc-parallel.c (GOACC_parallel_keyed_internal): Set device_api for
> + profiling.
> --- a/libgomp/oacc-parallel.c
> +++ b/libgomp/oacc-parallel.c
> @@ -275,6 +275,8 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
> goacc_call_host_fn (fn, mapnum, hostaddrs, params);
> goto out_prof;
> }
> + else if (profiling_p)
> + api_info.device_api = acc_device_api_cuda;
That change is not quite right, and I'm pretty sure it wasn't me who
introduced that code ;-P -- but that can be resolved later.
> --- a/libgomp/Makefile.in
> +++ b/libgomp/Makefile.in
> @@ -524,7 +525,7 @@ search_path = $(addprefix $(top_srcdir)/config/, $(config_path)) $(top_srcdir) \
>
> fincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)$(MULTISUBDIR)/finclude
> libsubincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)/include
> -libgomp_la_LIBADD = $(LIBFFI)
> +@USE_LIBFFI_TRUE@libgomp_la_LIBADD = $(LIBFFI)
That must've been an earlier commit not properly regenerating the file,
but we shall not bother with that now.
> diff --git a/libgomp/config/nvptx/oacc-profiling-acc_register_library.c b/libgomp/config/nvptx/oacc-profiling-acc_register_library.c
> new file mode 100644
> index 0000000..e69de29
> diff --git a/libgomp/config/nvptx/oacc-profiling.c b/libgomp/config/nvptx/oacc-profiling.c
> new file mode 100644
> index 0000000..e69de29
Not sure if these empty files are actually needed, but no harm done, so
that can be resolved later.
> --- a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
> +++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
> @@ -41,6 +41,7 @@ static int state = -1;
> static acc_device_t acc_device_type;
> static int acc_device_num;
> static int num_gangs, num_workers, vector_length;
> +static int async;
All these 'async' changes in this file logically belong into the
respective commit of the OpenACC 'kernels' changes. It's not a problem
to have them included here; we shall just try to remember to include them
in the OpenACC 'kernels' trunk changes. (I've made a note; no need for
you to re-test/re-post.)
> @@ -165,6 +166,15 @@ int main()
> for (int i = 0; i < N; ++i)
> x[i] = i * i;
> }
> +#ifdef __OPTIMIZE__
> + /* TODO. With -O2 optimizations enabled, the compiler believes that here
> + "state == 0" still holds. It's not yet clear what's going on.
> + Mis-optimization across the GOMP function call boundary? Per its
> + gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
> + "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
> + must expect calls back into this compilation unit? */
> + asm volatile ("" : : : "memory");
> +#endif
That workaround is no longer needed given the more specific workaround
that I've added, marked with "TODO PR90488".
> @@ -184,12 +196,22 @@ int main()
> for (int i = 0; i < N; ++i)
> x[i] = i * i;
> }
> +#ifdef __OPTIMIZE__
> + /* TODO. With -O2 optimizations enabled, the compiler believes that here
> + "state == 0" still holds. It's not yet clear what's going on.
> + Mis-optimization across the GOMP function call boundary? Per its
> + gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
> + "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
> + must expect calls back into this compilation unit? */
> + asm volatile ("" : : : "memory");
> +#endif
Likewise.
> @@ -209,12 +233,22 @@ int main()
> for (int i = 0; i < N; ++i)
> x[i] = i * i;
> }
> +#ifdef __OPTIMIZE__
> + /* TODO. With -O2 optimizations enabled, the compiler believes that here
> + "state == 0" still holds. It's not yet clear what's going on.
> + Mis-optimization across the GOMP function call boundary? Per its
> + gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
> + "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
> + must expect calls back into this compilation unit? */
> + asm volatile ("" : : : "memory");
> +#endif
Likewise.
> --- a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
> +++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
> @@ -697,6 +695,15 @@ int main()
> }
> assert (state_init == 4);
> }
> +#ifdef __OPTIMIZE__
> + /* TODO. With -O2 optimizations enabled, the compiler believes that here
> + "state == 0" still holds. It's not yet clear what's going on.
> + Mis-optimization across the GOMP function call boundary? Per its
> + gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
> + "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
> + must expect calls back into this compilation unit? */
> + asm volatile ("" : : : "memory");
> +#endif
Likewise.
In 'libgomp.oacc-c-c++-common/acc_prof-version-1.c:main', we should also
remove the explicit call to 'acc_register_library'.
Grüße
Thomas
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 658 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH, og9] Port OpenACC profiling interface to OG9
2019-07-24 11:05 ` Thomas Schwinge
@ 2019-07-27 5:26 ` Kwok Cheung Yeung
0 siblings, 0 replies; 23+ messages in thread
From: Kwok Cheung Yeung @ 2019-07-27 5:26 UTC (permalink / raw)
To: Thomas Schwinge; +Cc: Catherine Moore, gcc-patches
On 24/07/2019 11:45 am, Thomas Schwinge wrote:
>> +2017-02-28 Thomas Schwinge <thomas@codesourcery.com>
>> +
>> + [...]
>> + * oacc-parallel.c (GOACC_parallel_keyed_internal): Set device_api for
>> + profiling.
>
>> --- a/libgomp/oacc-parallel.c
>> +++ b/libgomp/oacc-parallel.c
>> @@ -275,6 +275,8 @@ GOACC_parallel_keyed_internal (int flags_m, int params, void (*fn) (void *),
>> goacc_call_host_fn (fn, mapnum, hostaddrs, params);
>> goto out_prof;
>> }
>> + else if (profiling_p)
>> + api_info.device_api = acc_device_api_cuda;
>
> That change is not quite right, and I'm pretty sure it wasn't me who
> introduced that code ;-P -- but that can be resolved later.
>
git blame shows that that fragment was introduced in commit
fef820dc593f3ee87dd79532701ed709e249eca4 (on the OG8 branch) named 'OpenACC
async re-work'.
>> --- a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
>> +++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-kernels-1.c
>> @@ -41,6 +41,7 @@ static int state = -1;
>> static acc_device_t acc_device_type;
>> static int acc_device_num;
>> static int num_gangs, num_workers, vector_length;
>> +static int async;
>
> All these 'async' changes in this file logically belong into the
> respective commit of the OpenACC 'kernels' changes. It's not a problem
> to have them included here; we shall just try to remember to include them
> in the OpenACC 'kernels' trunk changes. (I've made a note; no need for
> you to re-test/re-post.)
>
This is because in OG8, the kernel changes came after the introduction of the
profiling interface code, while on OG9 it is the other way around.
>> @@ -165,6 +166,15 @@ int main()
>> for (int i = 0; i < N; ++i)
>> x[i] = i * i;
>> }
>> +#ifdef __OPTIMIZE__
>> + /* TODO. With -O2 optimizations enabled, the compiler believes that here
>> + "state == 0" still holds. It's not yet clear what's going on.
>> + Mis-optimization across the GOMP function call boundary? Per its
>> + gcc/omp-builtins.def definition, BUILT_IN_GOACC_PARALLEL
>> + "GOACC_parallel_keyed" doesn't have a "leaf" attribute, so the compiler
>> + must expect calls back into this compilation unit? */
>> + asm volatile ("" : : : "memory");
>> +#endif
>
> That workaround is no longer needed given the more specific workaround
> that I've added, marked with "TODO PR90488".
>
Removed.
> In 'libgomp.oacc-c-c++-common/acc_prof-version-1.c:main', we should also
> remove the explicit call to 'acc_register_library'.
>
Removed.
The patches have now been pushed to the openacc-gcc-9-branch git-only branch.
Kwok
^ permalink raw reply [flat|nested] 23+ messages in thread
* [og9] Fix og9 "Fix hang when running oacc exec with CUDA 9.0 nvprof"
2018-02-22 11:23 ` [og7] Fix hang when running oacc exec with CUDA 9.0 nvprof Tom de Vries
@ 2020-03-25 17:09 ` Thomas Schwinge
2020-03-26 16:46 ` [og9] Really fix " Thomas Schwinge
2020-07-13 15:29 ` [PATCH] libgomp: Fix hang when profiling OpenACC programs with CUDA 9.0 nvprof Kwok Cheung Yeung
1 sibling, 1 reply; 23+ messages in thread
From: Thomas Schwinge @ 2020-03-25 17:09 UTC (permalink / raw)
To: gcc-patches, Frederik Harwath
Cc: Catherine Moore, Julian Brown, Kwok Cheung Yeung
[-- Attachment #1: Type: text/plain, Size: 2977 bytes --]
Hi!
On 2018-02-22T12:23:25+0100, Tom de Vries <Tom_deVries@mentor.com> wrote:
> when using cuda 9 nvprof with an openacc executable, the executable hangs.
>
> The scenario resulting in the hang is as follows:
> 1. goacc_lazy_initialize calls gomp_mutex_lock (&acc_device_lock)
> 2. goacc_lazy_initialize calls acc_init_1
> 3. acc_init_1 calls goacc_profiling_dispatch (&prof_info,
> &device_init_event_info, &api_info);
> 4. goacc_profiling_dispatch calls the registered callback in the cuda
> profiling library
> 5. the registered call back calls acc_get_device_type
> 6. acc_get_device_type calls gomp_mutex_lock (&acc_device_lock)
> 7. The lock is not recursive, so we have deadlock
>
> The registered callback in cuda 8 does not call acc_get_device_type, so
> the hang doesn't occur there.
(ACK for the general problem description/analysis.)
> This patch fixes the hang by detecting in acc_get_device_type that the
> calling thread is a thread that is currently initializing the openacc
> part of the libgomp library, and returning acc_device_none, which is a
> legal value given that the openacc standard states "If the device type
> has not yet been selected, the value acc_device_none may be returned".
(This specific way of resolving the issue I still have to look into.
This may need a more general solution, to make all such libgomp OpenACC
entry points re-entrant.)
> Committed to og7 branch.
What Frederik has discovered today in the hard way... is that the og9
version of this patch did get its code altered in a way so that it no
longer resolves the problem it's meant to resolve -- the hang was back.
On Git-mirror-based openacc-gcc-9-branch that's:
commit 84af3c5a2fbb5023057e2ca319b0c22f5f7d4795
Author: Julian Brown <julian@codesourcery.com>
AuthorDate: Tue Feb 26 16:00:54 2019 -0800
Commit: Kwok Cheung Yeung <kcy@codesourcery.com>
CommitDate: Fri May 31 13:40:07 2019 -0700
Fix hang when running oacc exec with CUDA 9.0 nvprof
2018-09-20 Tom de Vries <tdevries@suse.de>
Cesar Philippidis <cesar@codesourcery.com>
libgomp/
[...]
..., which got cherry-picked (automated, without any review) into current
devel/omp/gcc-9 in commit f752d880a5abc591a25ad22fb892363f6520bcf1.
Of course, it would've helped tremendously had the original og7 commit
included a test case... :'-/ (... by simply reproducing the nested calls
that CUDA 9 nvprof seems to be doing.)
Still without a test case, for now I have pushed the attached patch to
devel/omp/gcc-9 in commit 9ae129017c7fc1fa638d6beedd3802b515ca692b 'Fix
og9 "Fix hang when running oacc exec with CUDA 9.0 nvprof"'.
Grüße
Thomas
-----------------
Mentor Graphics (Deutschland) GmbH, Arnulfstraße 201, 80634 München / Germany
Registergericht München HRB 106955, Geschäftsführer: Thomas Heurung, Alexander Walter
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-Fix-og9-Fix-hang-when-running-oacc-exec-with-CUD.og9.patch --]
[-- Type: text/x-diff, Size: 2092 bytes --]
From 9ae129017c7fc1fa638d6beedd3802b515ca692b Mon Sep 17 00:00:00 2001
From: Thomas Schwinge <thomas@codesourcery.com>
Date: Wed, 25 Mar 2020 17:57:02 +0100
Subject: [PATCH] Fix og9 "Fix hang when running oacc exec with CUDA 9.0
nvprof"
Compared to the original og7 version, and still-good og8 version, the og9
version of this patch did get its code altered in a way so that it no longer
resolves the problem it's meant to resolve -- the hang was back.
libgomp/
* oacc-init.c (acc_init_1): Move 'acc_init_state' logic to where
it belongs.
---
libgomp/ChangeLog.omp | 5 +++++
libgomp/oacc-init.c | 10 +++++-----
2 files changed, 10 insertions(+), 5 deletions(-)
diff --git a/libgomp/ChangeLog.omp b/libgomp/ChangeLog.omp
index 88957864a69..75c45917998 100644
--- a/libgomp/ChangeLog.omp
+++ b/libgomp/ChangeLog.omp
@@ -1,3 +1,8 @@
+2020-03-25 Thomas Schwinge <thomas@codesourcery.com>
+
+ * oacc-init.c (acc_init_1): Move 'acc_init_state' logic to where
+ it belongs.
+
2019-11-22 Kwok Cheung Yeung <kcy@codesourcery.com>
* testsuite/libgomp.oacc-fortran/lib-16.f90: Fix async-safety issue.
diff --git a/libgomp/oacc-init.c b/libgomp/oacc-init.c
index beeeb48c106..765fa2f3b95 100644
--- a/libgomp/oacc-init.c
+++ b/libgomp/oacc-init.c
@@ -231,6 +231,11 @@ acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)
static struct gomp_device_descr *
acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
{
+ gomp_mutex_lock (&acc_init_state_lock);
+ acc_init_state = initializing;
+ acc_init_thread = pthread_self ();
+ gomp_mutex_unlock (&acc_init_state_lock);
+
bool check_not_nested_p;
if (implicit)
{
@@ -293,11 +298,6 @@ acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
struct gomp_device_descr *base_dev, *acc_dev;
int ndevs;
- gomp_mutex_lock (&acc_init_state_lock);
- acc_init_state = initializing;
- acc_init_thread = pthread_self ();
- gomp_mutex_unlock (&acc_init_state_lock);
-
base_dev = resolve_device (d, true);
ndevs = base_dev->get_num_devices_func ();
--
2.17.1
^ permalink raw reply [flat|nested] 23+ messages in thread
* [og9] Really fix og9 "Fix hang when running oacc exec with CUDA 9.0 nvprof"
2020-03-25 17:09 ` [og9] Fix og9 "Fix hang when running oacc exec with CUDA 9.0 nvprof" Thomas Schwinge
@ 2020-03-26 16:46 ` Thomas Schwinge
2020-03-27 7:06 ` Frederik Harwath
0 siblings, 1 reply; 23+ messages in thread
From: Thomas Schwinge @ 2020-03-26 16:46 UTC (permalink / raw)
To: gcc-patches, Frederik Harwath
Cc: Catherine Moore, Julian Brown, Kwok Cheung Yeung
[-- Attachment #1: Type: text/plain, Size: 3066 bytes --]
Hi!
On 2020-03-25T18:09:25+0100, I wrote:
> On 2018-02-22T12:23:25+0100, Tom de Vries <Tom_deVries@mentor.com> wrote:
>> when using cuda 9 nvprof with an openacc executable, the executable hangs.
> What Frederik has discovered today in the hard way... is that the og9
> version of this patch did get its code altered in a way so that it no
> longer resolves the problem it's meant to resolve -- the hang was back.
> On Git-mirror-based openacc-gcc-9-branch that's:
>
> commit 84af3c5a2fbb5023057e2ca319b0c22f5f7d4795
> Author: Julian Brown <julian@codesourcery.com>
> AuthorDate: Tue Feb 26 16:00:54 2019 -0800
> Commit: Kwok Cheung Yeung <kcy@codesourcery.com>
> CommitDate: Fri May 31 13:40:07 2019 -0700
>
> Fix hang when running oacc exec with CUDA 9.0 nvprof
>
> 2018-09-20 Tom de Vries <tdevries@suse.de>
> Cesar Philippidis <cesar@codesourcery.com>
>
> libgomp/
> [...]
>
> ..., which got cherry-picked (automated, without any review) into current
> devel/omp/gcc-9 in commit f752d880a5abc591a25ad22fb892363f6520bcf1.
OK, I had confused myself here. I wrongly blamed that commit to be
responsible for the hang being back, when in fact it's only the later og9
"OpenACC Profiling Interface (incomplete)" backport from trunk that
introduced the problem. On Git-mirror-based openacc-gcc-9-branch that's:
commit 1246da4f164bcf2ec4430b89686a38c47e55b5f9
Author: tschwinge <tschwinge@138bc75d-0d04-0410-961f-82ee72b054a4>
AuthorDate: Fri May 17 19:13:36 2019 +0000
Commit: Kwok Cheung Yeung <kcy@codesourcery.com>
CommitDate: Fri Jul 26 14:32:02 2019 -0700
OpenACC Profiling Interface (incomplete)
libgomp/
[...]
..., which got cherry-picked (automated, without any review) into current
devel/omp/gcc-9 in commit 9342531a7fc9f6e368e37bbd4ea9f4d01f43514e.
The confusing thing was that the og9 "Fix hang when running oacc exec
with CUDA 9.0 nvprof" commit appears *before* the og9 "OpenACC Profiling
Interface (incomplete)" backport that it relates to.
And, in addition to that, I pushed the wrong (incomplete) version of my
fix.
> Of course, it would've helped tremendously had the original og7 commit
> included a test case... :'-/ (... by simply reproducing the nested calls
> that CUDA 9 nvprof seems to be doing.)
>
> Still without a test case, for now I have pushed the attached patch to
> devel/omp/gcc-9 in commit 9ae129017c7fc1fa638d6beedd3802b515ca692b 'Fix
> og9 "Fix hang when running oacc exec with CUDA 9.0 nvprof"'.
..., and now the attached patch to devel/omp/gcc-9 in commit
775f1686a3df68bd20370f1fabc6273883e2c5d2 'Really fix og9 "Fix hang when
running oacc exec with CUDA 9.0 nvprof"'.
Grüße
Thomas
-----------------
Mentor Graphics (Deutschland) GmbH, Arnulfstraße 201, 80634 München / Germany
Registergericht München HRB 106955, Geschäftsführer: Thomas Heurung, Alexander Walter
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-Really-fix-og9-Fix-hang-when-running-oacc-exec-w.og9.patch --]
[-- Type: text/x-diff, Size: 2692 bytes --]
From 775f1686a3df68bd20370f1fabc6273883e2c5d2 Mon Sep 17 00:00:00 2001
From: Thomas Schwinge <thomas@codesourcery.com>
Date: Thu, 26 Mar 2020 17:34:01 +0100
Subject: [PATCH] Really fix og9 "Fix hang when running oacc exec with CUDA 9.0
nvprof"
In my yesterday's commit 9ae129017c7fc1fa638d6beedd3802b515ca692b 'Fix og9 "Fix
hang when running oacc exec with CUDA 9.0 nvprof"', I wrongly blamed the og9
"Fix hang when running oacc exec with CUDA 9.0 nvprof" to be responsible for
the hang being back, when in fact it's only the later og9 "OpenACC Profiling
Interface (incomplete)" backport from trunk that introduced the problem.
The confusing thing was that the og9 "Fix hang when running oacc exec with CUDA
9.0 nvprof" commit appears *before* the og9 "OpenACC Profiling Interface
(incomplete)" backport that it relates to.
And, in addition to that, I pushed the wrong (incomplete) version of my fix.
libgomp/
* oacc-init.c (acc_init_1): Move other 'acc_init_state' logic to
where it belongs.
---
libgomp/ChangeLog.omp | 5 +++++
libgomp/oacc-init.c | 12 ++++++++----
2 files changed, 13 insertions(+), 4 deletions(-)
diff --git a/libgomp/ChangeLog.omp b/libgomp/ChangeLog.omp
index 75c45917998..922e00fbff5 100644
--- a/libgomp/ChangeLog.omp
+++ b/libgomp/ChangeLog.omp
@@ -1,3 +1,8 @@
+2020-03-26 Thomas Schwinge <thomas@codesourcery.com>
+
+ * oacc-init.c (acc_init_1): Move other 'acc_init_state' logic to
+ where it belongs.
+
2020-03-25 Thomas Schwinge <thomas@codesourcery.com>
* oacc-init.c (acc_init_1): Move 'acc_init_state' logic to where
diff --git a/libgomp/oacc-init.c b/libgomp/oacc-init.c
index 765fa2f3b95..40c14fa9bf2 100644
--- a/libgomp/oacc-init.c
+++ b/libgomp/oacc-init.c
@@ -317,10 +317,6 @@ acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
gomp_init_device (acc_dev);
gomp_mutex_unlock (&acc_dev->lock);
- gomp_mutex_lock (&acc_init_state_lock);
- acc_init_state = initialized;
- gomp_mutex_unlock (&acc_init_state_lock);
-
if (profiling_p)
{
prof_info.event_type = acc_ev_device_init_end;
@@ -329,6 +325,14 @@ acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
&api_info);
}
+ /* We're setting 'initialized' *after* 'goacc_profiling_dispatch', so that a
+ nested 'acc_get_device_type' called from a profiling callback still sees
+ 'initializing', so that we don't deadlock when it then again tries to lock
+ 'goacc_prof_lock'. See also the discussion in 'acc_get_device_type'. */
+ gomp_mutex_lock (&acc_init_state_lock);
+ acc_init_state = initialized;
+ gomp_mutex_unlock (&acc_init_state_lock);
+
return base_dev;
}
--
2.17.1
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [og9] Really fix og9 "Fix hang when running oacc exec with CUDA 9.0 nvprof"
2020-03-26 16:46 ` [og9] Really fix " Thomas Schwinge
@ 2020-03-27 7:06 ` Frederik Harwath
0 siblings, 0 replies; 23+ messages in thread
From: Frederik Harwath @ 2020-03-27 7:06 UTC (permalink / raw)
To: Thomas Schwinge, gcc-patches
Cc: Catherine Moore, Julian Brown, Kwok Cheung Yeung
Hi Thomas,
Thomas Schwinge <thomas@codesourcery.com> writes:
> On 2020-03-25T18:09:25+0100, I wrote:
>> On 2018-02-22T12:23:25+0100, Tom de Vries <Tom_deVries@mentor.com> wrote:
>>> when using cuda 9 nvprof with an openacc executable, the executable hangs.
>
>> What Frederik has discovered today in the hard way... [...]
>> -- the hang was back. [...]
> ..., and now the attached patch to devel/omp/gcc-9 in commit
> 775f1686a3df68bd20370f1fabc6273883e2c5d2 'Really fix og9 "Fix hang when
> running oacc exec with CUDA 9.0 nvprof"'.
Thanks for fixing this issue! I can confirm that nvprof now works on
code compiled from devel/omp/gcc-9. I have used nvprof 9.1.85 on Ubuntu
18.04 for testing.
Best regards,
Frederik
-----------------
Mentor Graphics (Deutschland) GmbH, Arnulfstraße 201, 80634 München / Germany
Registergericht München HRB 106955, Geschäftsführer: Thomas Heurung, Alexander Walter
^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH] libgomp: Fix hang when profiling OpenACC programs with CUDA 9.0 nvprof
@ 2020-07-13 15:29 ` Kwok Cheung Yeung
2020-07-14 11:00 ` Thomas Schwinge
0 siblings, 1 reply; 23+ messages in thread
From: Kwok Cheung Yeung @ 2020-07-13 15:29 UTC (permalink / raw)
To: GCC Patches, Jakub Jelinek, Thomas Schwinge
[-- Attachment #1: Type: text/plain, Size: 1163 bytes --]
Hello
(This patch was previously posted for OG7 at:
https://gcc.gnu.org/pipermail/gcc-patches/2018-February/494594.html).
When the version of nvprof in CUDA 9.0 is run on an OpenACC program, it sets up
a callback that is called on device initialization. Inside the callback, it
calls the acc_get_device_type() function in libgomp. Inside
acc_get_device_type(), it attempts to acquire the acc_device_lock lock, but that
has already been acquired by goacc_lazy_initialize() at this point, so the
program deadlocks.
This is fixed by making acc_get_device_type() return acc_device_none without
attempting to acequire the lock when initialization has not finished yet. This
appears to be legal according to the OpenACC spec, since it states 'If the
device type has not yet been selected, the value acc_device_none may be
returned.' (in section 3.2.3 of the OpenACC 2.7 spec).
I have added a testcase that sets up the situation presented by nvprof. This
testcase hangs without the patch (hence the short dg-timeout), and passes with
it. Tested on a x86-64 host with Nvidia and AMD GCN offloading.
Okay for master, GCC 10 branch and OG10?
Thanks
Kwok
[-- Attachment #2: nvprof_hang.patch --]
[-- Type: text/plain, Size: 5659 bytes --]
commit d20f269e8571a76d682a500e78654ddd260ffaf1
Author: Kwok Cheung Yeung <kcy@codesourcery.com>
Date: Fri Jul 10 14:06:26 2020 -0700
libgomp: Fix hang when profiling OpenACC programs with CUDA 9.0 nvprof
The version of nvprof in CUDA 9.0 causes a hang when used to profile an
OpenACC program. This is because it calls acc_get_device_type from
a callback called during device initialization, which then attempts
to acquire acc_device_lock while it is already taken, resulting in
deadlock. This works around the issue by returning acc_device_none
from acc_get_device_type without attempting to acquire the lock when
initialization has not completed yet.
2020-07-13 Tom de Vries <tdevries@suse.de>
Cesar Philippidis <cesar@codesourcery.com>
Thomas Schwinge <thomas@codesourcery.com>
Kwok Cheung Yeung <kcy@codesourcery.com>
libgomp/
* oacc-init.c (acc_init_state_lock, acc_init_state, acc_init_thread):
New variable.
(acc_init_1): Set acc_init_thread to pthread_self (). Set
acc_init_state to initializing at the start, and to initialized at the
end.
(self_initializing_p): New function.
(acc_get_device_type): Return acc_device_none if called by thread that
is currently executing acc_init_1.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c: New.
diff --git a/libgomp/oacc-init.c b/libgomp/oacc-init.c
index 5d786a5..1e7f934 100644
--- a/libgomp/oacc-init.c
+++ b/libgomp/oacc-init.c
@@ -40,6 +40,11 @@
static gomp_mutex_t acc_device_lock;
+static gomp_mutex_t acc_init_state_lock;
+static enum { uninitialized, initializing, initialized } acc_init_state
+ = uninitialized;
+static pthread_t acc_init_thread;
+
/* A cached version of the dispatcher for the global "current" accelerator type,
e.g. used as the default when creating new host threads. This is the
device-type equivalent of goacc_device_num (which specifies which device to
@@ -228,6 +233,11 @@ acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)
static struct gomp_device_descr *
acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
{
+ gomp_mutex_lock (&acc_init_state_lock);
+ acc_init_state = initializing;
+ acc_init_thread = pthread_self ();
+ gomp_mutex_unlock (&acc_init_state_lock);
+
bool check_not_nested_p;
if (implicit)
{
@@ -317,6 +327,14 @@ acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
&api_info);
}
+ /* We're setting 'initialized' *after* 'goacc_profiling_dispatch', so that a
+ nested 'acc_get_device_type' called from a profiling callback still sees
+ 'initializing', so that we don't deadlock when it then again tries to lock
+ 'goacc_prof_lock'. See also the discussion in 'acc_get_device_type'. */
+ gomp_mutex_lock (&acc_init_state_lock);
+ acc_init_state = initialized;
+ gomp_mutex_unlock (&acc_init_state_lock);
+
return base_dev;
}
@@ -643,6 +661,17 @@ acc_set_device_type (acc_device_t d)
ialias (acc_set_device_type)
+static bool
+self_initializing_p (void)
+{
+ bool res;
+ gomp_mutex_lock (&acc_init_state_lock);
+ res = (acc_init_state == initializing
+ && pthread_equal (acc_init_thread, pthread_self ()));
+ gomp_mutex_unlock (&acc_init_state_lock);
+ return res;
+}
+
acc_device_t
acc_get_device_type (void)
{
@@ -652,6 +681,15 @@ acc_get_device_type (void)
if (thr && thr->base_dev)
res = acc_device_type (thr->base_dev->type);
+ else if (self_initializing_p ())
+ /* The Cuda libaccinj64.so version 9.0+ calls acc_get_device_type during the
+ acc_ev_device_init_start event callback, which is dispatched during
+ acc_init_1. Trying to lock acc_device_lock during such a call (as we do
+ in the else clause below), will result in deadlock, since the lock has
+ already been taken by the acc_init_1 caller. We work around this problem
+ by using the acc_get_device_type property "If the device type has not yet
+ been selected, the value acc_device_none may be returned". */
+ ;
else
{
acc_prof_info prof_info;
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c
new file mode 100644
index 0000000..6114164
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-timeout 10 } */
+
+/* Test the calling of acc_get_device_type() from within the device_init_start
+ callback. This occurs when the CUDA 9.0 nvprof tool is used, and can
+ deadlock if not handled properly. */
+
+#include <acc_prof.h>
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+static acc_device_t acc_device_type;
+
+static void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ acc_device_type = acc_get_device_type ();
+}
+
+int main(void)
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+
+ acc_init (acc_device_host);
+ acc_shutdown (acc_device_host);
+
+ acc_init (acc_device_default);
+ acc_shutdown (acc_device_default);
+}
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH] libgomp: Fix hang when profiling OpenACC programs with CUDA 9.0 nvprof
2020-07-13 15:29 ` [PATCH] libgomp: Fix hang when profiling OpenACC programs with CUDA 9.0 nvprof Kwok Cheung Yeung
@ 2020-07-14 11:00 ` Thomas Schwinge
0 siblings, 0 replies; 23+ messages in thread
From: Thomas Schwinge @ 2020-07-14 11:00 UTC (permalink / raw)
To: Kwok Cheung Yeung; +Cc: gcc-patches, Jakub Jelinek
[-- Attachment #1: Type: text/plain, Size: 7071 bytes --]
Hi Kwok!
On 2020-07-13T16:29:14+0100, Kwok Cheung Yeung <kcy@codesourcery.com> wrote:
> When the version of nvprof in CUDA 9.0 is run on an OpenACC program, [...] the
> program deadlocks.
> I have added a testcase that sets up the situation presented by nvprof.
Thanks. I have extended this one a little bit, to add some state
tracking to verify that we get the expected callbacks invoked, test what
we expect returned from 'acc_get_device_type', and in addition to your
'acc_ev_device_init_start' also verify the corresponding
'acc_ev_device_init_end'.
I've also updated the documentation.
> This
> testcase hangs without the patch (hence the short dg-timeout), and passes with
> it.
(Thus, 'dg-timeout' not really necessary anymore, but OK to leave in if
you'd like.)
> Okay for master, GCC 10 branch and OG10?
Thanks, OK, with the incremental patch merged in, unless there's anything
to discuss further.
> libgomp: Fix hang when profiling OpenACC programs with CUDA 9.0 nvprof
>
> The version of nvprof in CUDA 9.0 causes a hang when used to profile an
> OpenACC program. This is because it calls acc_get_device_type from
> a callback called during device initialization, which then attempts
> to acquire acc_device_lock while it is already taken, resulting in
> deadlock. This works around the issue by returning acc_device_none
> from acc_get_device_type without attempting to acquire the lock when
> initialization has not completed yet.
>
> 2020-07-13 Tom de Vries <tdevries@suse.de>
Should use Tom's CodeSourcery address, given that's when this work was
done.
> Cesar Philippidis <cesar@codesourcery.com>
> Thomas Schwinge <thomas@codesourcery.com>
> Kwok Cheung Yeung <kcy@codesourcery.com>
Grüße
Thomas
> libgomp/
> * oacc-init.c (acc_init_state_lock, acc_init_state, acc_init_thread):
> New variable.
> (acc_init_1): Set acc_init_thread to pthread_self (). Set
> acc_init_state to initializing at the start, and to initialized at the
> end.
> (self_initializing_p): New function.
> (acc_get_device_type): Return acc_device_none if called by thread that
> is currently executing acc_init_1.
> * testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c: New.
>
> diff --git a/libgomp/oacc-init.c b/libgomp/oacc-init.c
> index 5d786a5..1e7f934 100644
> --- a/libgomp/oacc-init.c
> +++ b/libgomp/oacc-init.c
> @@ -40,6 +40,11 @@
>
> static gomp_mutex_t acc_device_lock;
>
> +static gomp_mutex_t acc_init_state_lock;
> +static enum { uninitialized, initializing, initialized } acc_init_state
> + = uninitialized;
> +static pthread_t acc_init_thread;
> +
> /* A cached version of the dispatcher for the global "current" accelerator type,
> e.g. used as the default when creating new host threads. This is the
> device-type equivalent of goacc_device_num (which specifies which device to
> @@ -228,6 +233,11 @@ acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)
> static struct gomp_device_descr *
> acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
> {
> + gomp_mutex_lock (&acc_init_state_lock);
> + acc_init_state = initializing;
> + acc_init_thread = pthread_self ();
> + gomp_mutex_unlock (&acc_init_state_lock);
> +
> bool check_not_nested_p;
> if (implicit)
> {
> @@ -317,6 +327,14 @@ acc_init_1 (acc_device_t d, acc_construct_t parent_construct, int implicit)
> &api_info);
> }
>
> + /* We're setting 'initialized' *after* 'goacc_profiling_dispatch', so that a
> + nested 'acc_get_device_type' called from a profiling callback still sees
> + 'initializing', so that we don't deadlock when it then again tries to lock
> + 'goacc_prof_lock'. See also the discussion in 'acc_get_device_type'. */
> + gomp_mutex_lock (&acc_init_state_lock);
> + acc_init_state = initialized;
> + gomp_mutex_unlock (&acc_init_state_lock);
> +
> return base_dev;
> }
>
> @@ -643,6 +661,17 @@ acc_set_device_type (acc_device_t d)
>
> ialias (acc_set_device_type)
>
> +static bool
> +self_initializing_p (void)
> +{
> + bool res;
> + gomp_mutex_lock (&acc_init_state_lock);
> + res = (acc_init_state == initializing
> + && pthread_equal (acc_init_thread, pthread_self ()));
> + gomp_mutex_unlock (&acc_init_state_lock);
> + return res;
> +}
> +
> acc_device_t
> acc_get_device_type (void)
> {
> @@ -652,6 +681,15 @@ acc_get_device_type (void)
>
> if (thr && thr->base_dev)
> res = acc_device_type (thr->base_dev->type);
> + else if (self_initializing_p ())
> + /* The Cuda libaccinj64.so version 9.0+ calls acc_get_device_type during the
> + acc_ev_device_init_start event callback, which is dispatched during
> + acc_init_1. Trying to lock acc_device_lock during such a call (as we do
> + in the else clause below), will result in deadlock, since the lock has
> + already been taken by the acc_init_1 caller. We work around this problem
> + by using the acc_get_device_type property "If the device type has not yet
> + been selected, the value acc_device_none may be returned". */
> + ;
> else
> {
> acc_prof_info prof_info;
> diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c
> new file mode 100644
> index 0000000..6114164
> --- /dev/null
> +++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c
> @@ -0,0 +1,39 @@
> +/* { dg-do run } */
> +/* { dg-timeout 10 } */
> +
> +/* Test the calling of acc_get_device_type() from within the device_init_start
> + callback. This occurs when the CUDA 9.0 nvprof tool is used, and can
> + deadlock if not handled properly. */
> +
> +#include <acc_prof.h>
> +
> +static acc_prof_reg reg;
> +static acc_prof_reg unreg;
> +static acc_prof_lookup_func lookup;
> +
> +void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
> +{
> + reg = reg_;
> + unreg = unreg_;
> + lookup = lookup_;
> +}
> +
> +static acc_device_t acc_device_type;
> +
> +static void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
> +{
> + acc_device_type = acc_get_device_type ();
> +}
> +
> +int main(void)
> +{
> + acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
> +
> + reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
> +
> + acc_init (acc_device_host);
> + acc_shutdown (acc_device_host);
> +
> + acc_init (acc_device_default);
> + acc_shutdown (acc_device_default);
> +}
-----------------
Mentor Graphics (Deutschland) GmbH, Arnulfstraße 201, 80634 München / Germany
Registergericht München HRB 106955, Geschäftsführer: Thomas Heurung, Alexander Walter
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-into-libgomp-Fix-hang-when-profiling-OpenACC-program.patch --]
[-- Type: text/x-diff, Size: 5954 bytes --]
From 82e43a3263068e006dc96f9bf0ace033e45038ef Mon Sep 17 00:00:00 2001
From: Thomas Schwinge <thomas@codesourcery.com>
Date: Tue, 14 Jul 2020 12:43:53 +0200
Subject: [PATCH] into "libgomp: Fix hang when profiling OpenACC programs with
CUDA 9.0 nvprof"
---
libgomp/libgomp.texi | 11 +++
.../acc_prof-cb-call.c | 39 ---------
.../acc_prof-init-2.c | 80 +++++++++++++++++++
3 files changed, 91 insertions(+), 39 deletions(-)
delete mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c
create mode 100644 libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-2.c
diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi
index b946743f9b1..5331230c207 100644
--- a/libgomp/libgomp.texi
+++ b/libgomp/libgomp.texi
@@ -1967,6 +1967,12 @@ in @var{devicetype}, to use when executing a parallel or kernels region.
This function returns what device type will be used when executing a
parallel or kernels region.
+This function returns @code{acc_device_none} if
+@code{acc_get_device_type} is called from
+@code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}
+callbacks of the OpenACC Profiling Interface (@ref{OpenACC Profiling
+Interface}), that is, if the device is currently being initialized.
+
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
@item @emph{Prototype}: @tab @code{acc_device_t acc_get_device_type(void);}
@@ -3382,6 +3388,11 @@ every event that has been registered.
We're not yet accounting for the fact that @cite{OpenACC events may
occur during event processing}.
+We just handle one case specially, as required by CUDA 9.0
+@command{nvprof}, that @code{acc_get_device_type}
+(@ref{acc_get_device_type})) may be called from
+@code{acc_ev_device_init_start}, @code{acc_ev_device_init_end}
+callbacks.
We're not yet implementing initialization via a
@code{acc_register_library} function that is either statically linked
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c
deleted file mode 100644
index 6114164aa24..00000000000
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-cb-call.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/* { dg-do run } */
-/* { dg-timeout 10 } */
-
-/* Test the calling of acc_get_device_type() from within the device_init_start
- callback. This occurs when the CUDA 9.0 nvprof tool is used, and can
- deadlock if not handled properly. */
-
-#include <acc_prof.h>
-
-static acc_prof_reg reg;
-static acc_prof_reg unreg;
-static acc_prof_lookup_func lookup;
-
-void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
-{
- reg = reg_;
- unreg = unreg_;
- lookup = lookup_;
-}
-
-static acc_device_t acc_device_type;
-
-static void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
-{
- acc_device_type = acc_get_device_type ();
-}
-
-int main(void)
-{
- acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
-
- reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
-
- acc_init (acc_device_host);
- acc_shutdown (acc_device_host);
-
- acc_init (acc_device_default);
- acc_shutdown (acc_device_default);
-}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-2.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-2.c
new file mode 100644
index 00000000000..fab595cd463
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-2.c
@@ -0,0 +1,80 @@
+/* { dg-do run } */
+/* { dg-timeout 10 } */
+
+/* Test the calling of 'acc_get_device_type' from within
+ 'cb_device_init_start', 'cb_device_init_end' callbacks. This occurs when
+ the CUDA 9.0 'nvprof' tool is used, and did deadlock. */
+
+#include <assert.h>
+#include <stdbool.h>
+#include <acc_prof.h>
+
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+static bool expect_cb_device_init_start;
+static bool expect_cb_device_init_end;
+
+static void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ assert (expect_cb_device_init_start);
+ expect_cb_device_init_start = false;
+
+ acc_device_t acc_device_type;
+ acc_device_type = acc_get_device_type ();
+ assert (acc_device_type == acc_device_none);
+
+ expect_cb_device_init_end = true;
+}
+
+static void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
+{
+ assert (expect_cb_device_init_end);
+ expect_cb_device_init_end = false;
+
+ acc_device_t acc_device_type;
+ acc_device_type = acc_get_device_type ();
+ assert (acc_device_type == acc_device_none);
+}
+
+int main(void)
+{
+ acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
+
+ reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
+ reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
+
+ expect_cb_device_init_start = true;
+ expect_cb_device_init_end = false;
+ acc_init (acc_device_host);
+ assert (!expect_cb_device_init_start);
+ assert (!expect_cb_device_init_end);
+ {
+ acc_device_t acc_device_type;
+ acc_device_type = acc_get_device_type ();
+ assert (acc_device_type == acc_device_host);
+ }
+ acc_shutdown (acc_device_host);
+
+ expect_cb_device_init_start = true;
+ expect_cb_device_init_end = false;
+ acc_init (acc_device_default);
+ assert (!expect_cb_device_init_start);
+ assert (!expect_cb_device_init_end);
+ {
+ acc_device_t acc_device_type;
+ acc_device_type = acc_get_device_type ();
+ assert (acc_device_type != acc_device_none);
+ }
+ acc_shutdown (acc_device_default);
+
+ return 0;
+}
--
2.17.1
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [committed] OpenACC Profiling Interface (incomplete)
2019-05-17 19:19 ` [committed] OpenACC Profiling Interface (incomplete) Thomas Schwinge
2019-06-17 13:27 ` [PATCH, og9] Port OpenACC profiling interface to OG9 Kwok Cheung Yeung
@ 2021-07-27 9:33 ` Thomas Schwinge
1 sibling, 0 replies; 23+ messages in thread
From: Thomas Schwinge @ 2021-07-27 9:33 UTC (permalink / raw)
To: gcc-patches; +Cc: Julian Brown
[-- Attachment #1: Type: text/plain, Size: 859 bytes --]
Hi!
On 2019-05-17T21:19:07+0200, I wrote:
> Committed to trunk in r271346 "OpenACC Profiling Interface (incomplete)"
There in an 'async' issue in two of the test cases added here, as figured
out during review/testing with GCN offloading Julian's patch to 'Fix
OpenACC "ephemeral" asynchronous host-to-device copies'. I've pushed
"[OpenACC] Clarify sequencing of 'async' data copying vs. profiling
events in 'libgomp.oacc-c-c++-common/acc_prof-{init,parallel}-1.c'" to
master branch in commit 29ddaf43f70e19fd1110b539e8b3d0436c757e34, see
attached.
Grüße
Thomas
-----------------
Siemens Electronic Design Automation GmbH; Anschrift: Arnulfstraße 201, 80634 München; Gesellschaft mit beschränkter Haftung; Geschäftsführer: Thomas Heurung, Frank Thürauf; Sitz der Gesellschaft: München; Registergericht München, HRB 106955
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-OpenACC-Clarify-sequencing-of-async-data-copying-vs..patch --]
[-- Type: text/x-diff, Size: 7245 bytes --]
From 29ddaf43f70e19fd1110b539e8b3d0436c757e34 Mon Sep 17 00:00:00 2001
From: Thomas Schwinge <thomas@codesourcery.com>
Date: Fri, 23 Jul 2021 15:07:34 +0200
Subject: [PATCH] [OpenACC] Clarify sequencing of 'async' data copying vs.
profiling events in 'libgomp.oacc-c-c++-common/acc_prof-{init,parallel}-1.c'
... as noticed with GCN offloading.
Fix-up for r271346 (commit 5fae049dc272144f8e61af94ee0ba42b270915e5)
"OpenACC Profiling Interface (incomplete)".
libgomp/
* testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c: Clarify
sequencing of 'async' data copying vs. profiling events.
* testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c:
Likewise.
---
.../acc_prof-init-1.c | 49 ++++++++++++------
.../acc_prof-parallel-1.c | 51 +++++++++++++------
2 files changed, 68 insertions(+), 32 deletions(-)
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
index 7d05f482f46..b5e77155460 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c
@@ -19,6 +19,19 @@
#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
static int state = -1;
#define STATE_OP(state, op) \
@@ -34,7 +47,7 @@ static int state = -1;
static acc_device_t acc_device_type;
static int acc_device_num;
-static int acc_async;
+static int acc_async = acc_async_sync;
struct tool_info
@@ -192,6 +205,21 @@ static void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *
assert (state == 11
|| state == 111);
+#if defined COPYIN
+ /* In an 'async' setting, this event may be triggered before actual 'async'
+ data copying has completed. Given that 'state' appears in 'COPYIN', we
+ first have to synchronize (that is, let the 'async' 'COPYIN' read the
+ current 'state' value)... */
+ if (acc_async != acc_async_sync)
+ {
+ /* "We're not yet accounting for the fact that _OpenACC events may occur
+ during event processing_"; temporarily disable to avoid deadlock. */
+ unreg (acc_ev_none, NULL, acc_toggle_per_thread);
+ acc_wait (acc_async);
+ reg (acc_ev_none, NULL, acc_toggle_per_thread);
+ }
+ /* ... before modifying it in the following. */
+#endif
STATE_OP (state, ++);
assert (tool_info != NULL);
@@ -240,19 +268,6 @@ static void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *
}
-static acc_prof_reg reg;
-static acc_prof_reg unreg;
-static acc_prof_lookup_func lookup;
-void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
-{
- DEBUG_printf ("%s\n", __FUNCTION__);
-
- reg = reg_;
- unreg = unreg_;
- lookup = lookup_;
-}
-
-
int main()
{
acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
@@ -271,14 +286,15 @@ int main()
acc_device_type = acc_get_device_type ();
acc_device_num = acc_get_device_num (acc_device_type);
- acc_async = 12;
{
int state_init;
+ acc_async = 12;
#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
{
state_init = state;
}
+ acc_async = acc_async_sync;
#pragma acc wait
assert (state_init == 11);
}
@@ -297,14 +313,15 @@ int main()
acc_device_type = acc_get_device_type ();
acc_device_num = acc_get_device_num (acc_device_type);
- acc_async = 12;
{
int state_init;
+ acc_async = 12;
#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
{
state_init = state;
}
+ acc_async = acc_async_sync;
#pragma acc wait
assert (state_init == 111);
}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
index a5e9ab3f936..1f503861cb6 100644
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-parallel-1.c
@@ -29,6 +29,19 @@
#define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
+static acc_prof_reg reg;
+static acc_prof_reg unreg;
+static acc_prof_lookup_func lookup;
+void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
+{
+ DEBUG_printf ("%s\n", __FUNCTION__);
+
+ reg = reg_;
+ unreg = unreg_;
+ lookup = lookup_;
+}
+
+
static int state = -1;
#define STATE_OP(state, op) \
@@ -44,7 +57,7 @@ static int state = -1;
static acc_device_t acc_device_type;
static int acc_device_num;
-static int acc_async;
+static int acc_async = acc_async_sync;
struct tool_info
@@ -235,6 +248,25 @@ static void cb_enter_data_end (acc_prof_info *prof_info, acc_event_info *event_i
assert (state == 4
|| state == 104);
+#if defined COPYIN
+ /* Conceptually, 'acc_ev_enter_data_end' marks the end of data copying,
+ before 'acc_ev_enqueue_launch_start' marks invoking the compute region.
+ That's the 'state_init = state;' intended to be captured in the compute
+ regions. */
+ /* In an 'async' setting, this event may be triggered before actual 'async'
+ data copying has completed. Given that 'state' appears in 'COPYIN', we
+ first have to synchronize (that is, let the 'async' 'COPYIN' read the
+ current 'state' value)... */
+ if (acc_async != acc_async_sync)
+ {
+ /* "We're not yet accounting for the fact that _OpenACC events may occur
+ during event processing_"; temporarily disable to avoid deadlock. */
+ unreg (acc_ev_none, NULL, acc_toggle_per_thread);
+ acc_wait (acc_async);
+ reg (acc_ev_none, NULL, acc_toggle_per_thread);
+ }
+ /* ... before modifying it in the following. */
+#endif
STATE_OP (state, ++);
assert (tool_info != NULL);
@@ -664,19 +696,6 @@ static void cb_enqueue_launch_end (acc_prof_info *prof_info, acc_event_info *eve
}
-static acc_prof_reg reg;
-static acc_prof_reg unreg;
-static acc_prof_lookup_func lookup;
-void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
-{
- DEBUG_printf ("%s\n", __FUNCTION__);
-
- reg = reg_;
- unreg = unreg_;
- lookup = lookup_;
-}
-
-
int main()
{
acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
@@ -696,7 +715,6 @@ int main()
acc_device_type = acc_get_device_type ();
acc_device_num = acc_get_device_num (acc_device_type);
- acc_async = acc_async_sync;
assert (state == 0);
{
@@ -713,15 +731,16 @@ int main()
STATE_OP (state, = 100);
- acc_async = 12;
{
int state_init;
+ acc_async = 12;
#pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
{
asm volatile ("" : : : "memory"); // TODO PR90488
state_init = state;
}
+ acc_async = acc_async_sync;
#pragma acc wait
assert (state_init == 104);
}
--
2.30.2
^ permalink raw reply [flat|nested] 23+ messages in thread
end of thread, other threads:[~2021-07-27 9:33 UTC | newest]
Thread overview: 23+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2017-02-28 17:54 OpenACC 2.5 Profiling Interface (incomplete) Thomas Schwinge
2017-05-15 7:38 ` More OpenACC 2.5 Profiling Interface (was: OpenACC 2.5 Profiling Interface (incomplete)) Thomas Schwinge
2017-05-15 11:55 ` Documentation changes for OpenACC 2.5 Profiling Interface (was: More OpenACC 2.5 Profiling Interface) Thomas Schwinge
2018-02-22 11:23 ` [og7] Fix hang when running oacc exec with CUDA 9.0 nvprof Tom de Vries
2020-03-25 17:09 ` [og9] Fix og9 "Fix hang when running oacc exec with CUDA 9.0 nvprof" Thomas Schwinge
2020-03-26 16:46 ` [og9] Really fix " Thomas Schwinge
2020-03-27 7:06 ` Frederik Harwath
2020-07-13 15:29 ` [PATCH] libgomp: Fix hang when profiling OpenACC programs with CUDA 9.0 nvprof Kwok Cheung Yeung
2020-07-14 11:00 ` Thomas Schwinge
2018-11-12 4:32 ` OpenACC 2.5 Profiling Interface Thomas Schwinge
2018-12-04 13:13 ` Jakub Jelinek
2019-05-15 14:28 ` Thomas Schwinge
2019-05-16 15:22 ` OpenACC Profiling Interface: 'acc_register_library' (was: OpenACC 2.5 Profiling Interface) Thomas Schwinge
2019-05-16 15:54 ` Jakub Jelinek
2019-05-16 19:43 ` OpenACC Profiling Interface: 'acc_register_library' Thomas Schwinge
2019-05-17 19:19 ` [committed] OpenACC Profiling Interface (incomplete) Thomas Schwinge
2019-06-17 13:27 ` [PATCH, og9] Port OpenACC profiling interface to OG9 Kwok Cheung Yeung
2019-06-17 13:28 ` Kwok Cheung Yeung
2019-06-17 17:24 ` Thomas Schwinge
2019-06-24 19:37 ` Kwok Cheung Yeung
2019-07-24 11:05 ` Thomas Schwinge
2019-07-27 5:26 ` Kwok Cheung Yeung
2021-07-27 9:33 ` [committed] OpenACC Profiling Interface (incomplete) Thomas Schwinge
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).