| /* OpenACC Profiling Interface |
| |
| Copyright (C) 2019-2022 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); |
| } |