1212 lines
47 KiB
C
1212 lines
47 KiB
C
#ifndef _BSD_SOURCE
|
|
#define _BSD_SOURCE
|
|
#endif
|
|
#ifndef _DEFAULT_SOURCE
|
|
#define _DEFAULT_SOURCE
|
|
#endif
|
|
#include <stdio.h>
|
|
#ifndef __STDC_FORMAT_MACROS
|
|
#define __STDC_FORMAT_MACROS
|
|
#endif
|
|
#include <inttypes.h>
|
|
#include <omp.h>
|
|
#include <omp-tools.h>
|
|
#include "ompt-signal.h"
|
|
|
|
// Used to detect architecture
|
|
#include "../../src/kmp_platform.h"
|
|
|
|
#ifndef _TOOL_PREFIX
|
|
#define _TOOL_PREFIX ""
|
|
// If no _TOOL_PREFIX is set, we assume that we run as part of an OMPT test
|
|
#define _OMPT_TESTS
|
|
#endif
|
|
|
|
static const char *ompt_thread_t_values[] = {
|
|
"ompt_thread_UNDEFINED", "ompt_thread_initial", "ompt_thread_worker",
|
|
"ompt_thread_other"};
|
|
|
|
static const char *ompt_task_status_t_values[] = {
|
|
"ompt_task_UNDEFINED",
|
|
"ompt_task_complete", // 1
|
|
"ompt_task_yield", // 2
|
|
"ompt_task_cancel", // 3
|
|
"ompt_task_detach", // 4
|
|
"ompt_task_early_fulfill", // 5
|
|
"ompt_task_late_fulfill", // 6
|
|
"ompt_task_switch" // 7
|
|
};
|
|
static const char* ompt_cancel_flag_t_values[] = {
|
|
"ompt_cancel_parallel",
|
|
"ompt_cancel_sections",
|
|
"ompt_cancel_loop",
|
|
"ompt_cancel_taskgroup",
|
|
"ompt_cancel_activated",
|
|
"ompt_cancel_detected",
|
|
"ompt_cancel_discarded_task"
|
|
};
|
|
|
|
static const char *ompt_dependence_type_t_values[] = {
|
|
"ompt_dependence_type_UNDEFINED",
|
|
"ompt_dependence_type_in", // 1
|
|
"ompt_dependence_type_out", // 2
|
|
"ompt_dependence_type_inout", // 3
|
|
"ompt_dependence_type_mutexinoutset", // 4
|
|
"ompt_dependence_type_source", // 5
|
|
"ompt_dependence_type_sink", // 6
|
|
"ompt_dependence_type_inoutset" // 7
|
|
};
|
|
|
|
static void format_task_type(int type, char *buffer) {
|
|
char *progress = buffer;
|
|
if (type & ompt_task_initial)
|
|
progress += sprintf(progress, "ompt_task_initial");
|
|
if (type & ompt_task_implicit)
|
|
progress += sprintf(progress, "ompt_task_implicit");
|
|
if (type & ompt_task_explicit)
|
|
progress += sprintf(progress, "ompt_task_explicit");
|
|
if (type & ompt_task_target)
|
|
progress += sprintf(progress, "ompt_task_target");
|
|
if (type & ompt_task_undeferred)
|
|
progress += sprintf(progress, "|ompt_task_undeferred");
|
|
if (type & ompt_task_untied)
|
|
progress += sprintf(progress, "|ompt_task_untied");
|
|
if (type & ompt_task_final)
|
|
progress += sprintf(progress, "|ompt_task_final");
|
|
if (type & ompt_task_mergeable)
|
|
progress += sprintf(progress, "|ompt_task_mergeable");
|
|
if (type & ompt_task_merged)
|
|
progress += sprintf(progress, "|ompt_task_merged");
|
|
}
|
|
|
|
static ompt_set_callback_t ompt_set_callback;
|
|
static ompt_get_callback_t ompt_get_callback;
|
|
static ompt_get_state_t ompt_get_state;
|
|
static ompt_get_task_info_t ompt_get_task_info;
|
|
static ompt_get_task_memory_t ompt_get_task_memory;
|
|
static ompt_get_thread_data_t ompt_get_thread_data;
|
|
static ompt_get_parallel_info_t ompt_get_parallel_info;
|
|
static ompt_get_unique_id_t ompt_get_unique_id;
|
|
static ompt_finalize_tool_t ompt_finalize_tool;
|
|
static ompt_get_num_procs_t ompt_get_num_procs;
|
|
static ompt_get_num_places_t ompt_get_num_places;
|
|
static ompt_get_place_proc_ids_t ompt_get_place_proc_ids;
|
|
static ompt_get_place_num_t ompt_get_place_num;
|
|
static ompt_get_partition_place_nums_t ompt_get_partition_place_nums;
|
|
static ompt_get_proc_id_t ompt_get_proc_id;
|
|
static ompt_enumerate_states_t ompt_enumerate_states;
|
|
static ompt_enumerate_mutex_impls_t ompt_enumerate_mutex_impls;
|
|
|
|
static void print_ids(int level)
|
|
{
|
|
int task_type, thread_num;
|
|
ompt_frame_t *frame;
|
|
ompt_data_t *task_parallel_data;
|
|
ompt_data_t *task_data;
|
|
int exists_task = ompt_get_task_info(level, &task_type, &task_data, &frame,
|
|
&task_parallel_data, &thread_num);
|
|
char buffer[2048];
|
|
format_task_type(task_type, buffer);
|
|
if (frame)
|
|
printf("%" PRIu64 ": task level %d: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", exit_frame=%p, reenter_frame=%p, "
|
|
"task_type=%s=%d, thread_num=%d\n",
|
|
ompt_get_thread_data()->value, level,
|
|
exists_task ? task_parallel_data->value : 0,
|
|
exists_task ? task_data->value : 0, frame->exit_frame.ptr,
|
|
frame->enter_frame.ptr, buffer, task_type, thread_num);
|
|
}
|
|
|
|
#define get_frame_address(level) __builtin_frame_address(level)
|
|
|
|
#define print_frame(level) \
|
|
printf("%" PRIu64 ": __builtin_frame_address(%d)=%p\n", \
|
|
ompt_get_thread_data()->value, level, get_frame_address(level))
|
|
|
|
// clang (version 5.0 and above) adds an intermediate function call with debug flag (-g)
|
|
#if defined(TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN)
|
|
#if defined(DEBUG) && defined(__clang__) && __clang_major__ >= 5
|
|
#define print_frame_from_outlined_fn(level) print_frame(level+1)
|
|
#else
|
|
#define print_frame_from_outlined_fn(level) print_frame(level)
|
|
#endif
|
|
|
|
#if defined(__clang__) && __clang_major__ >= 5
|
|
#warning "Clang 5.0 and later add an additional wrapper for outlined functions when compiling with debug information."
|
|
#warning "Please define -DDEBUG iff you manually pass in -g to make the tests succeed!"
|
|
#endif
|
|
#endif
|
|
|
|
// This macro helps to define a label at the current position that can be used
|
|
// to get the current address in the code.
|
|
//
|
|
// For print_current_address():
|
|
// To reliably determine the offset between the address of the label and the
|
|
// actual return address, we insert a NOP instruction as a jump target as the
|
|
// compiler would otherwise insert an instruction that we can't control. The
|
|
// instruction length is target dependent and is explained below.
|
|
//
|
|
// (The empty block between "#pragma omp ..." and the __asm__ statement is a
|
|
// workaround for a bug in the Intel Compiler.)
|
|
#define define_ompt_label(id) \
|
|
{} \
|
|
__asm__("nop"); \
|
|
ompt_label_##id:
|
|
|
|
// This macro helps to get the address of a label that is inserted by the above
|
|
// macro define_ompt_label(). The address is obtained with a GNU extension
|
|
// (&&label) that has been tested with gcc, clang and icc.
|
|
#define get_ompt_label_address(id) (&& ompt_label_##id)
|
|
|
|
// This macro prints the exact address that a previously called runtime function
|
|
// returns to.
|
|
#define print_current_address(id) \
|
|
define_ompt_label(id) \
|
|
print_possible_return_addresses(get_ompt_label_address(id))
|
|
|
|
#if KMP_ARCH_X86 || KMP_ARCH_X86_64
|
|
// On X86 the NOP instruction is 1 byte long. In addition, the compiler inserts
|
|
// a MOV instruction for non-void runtime functions which is 3 bytes long.
|
|
#define print_possible_return_addresses(addr) \
|
|
printf("%" PRIu64 ": current_address=%p or %p for non-void functions\n", \
|
|
ompt_get_thread_data()->value, ((char *)addr) - 1, ((char *)addr) - 4)
|
|
#elif KMP_ARCH_PPC64
|
|
// On Power the NOP instruction is 4 bytes long. In addition, the compiler
|
|
// inserts a second NOP instruction (another 4 bytes). For non-void runtime
|
|
// functions Clang inserts a STW instruction (but only if compiling under
|
|
// -fno-PIC which will be the default with Clang 8.0, another 4 bytes).
|
|
#define print_possible_return_addresses(addr) \
|
|
printf("%" PRIu64 ": current_address=%p or %p\n", ompt_get_thread_data()->value, \
|
|
((char *)addr) - 8, ((char *)addr) - 12)
|
|
#elif KMP_ARCH_AARCH64
|
|
// On AArch64 the NOP instruction is 4 bytes long, can be followed by inserted
|
|
// store instruction (another 4 bytes long).
|
|
#define print_possible_return_addresses(addr) \
|
|
printf("%" PRIu64 ": current_address=%p or %p\n", ompt_get_thread_data()->value, \
|
|
((char *)addr) - 4, ((char *)addr) - 8)
|
|
#elif KMP_ARCH_RISCV64
|
|
#if __riscv_compressed
|
|
// On RV64GC the C.NOP instruction is 2 byte long. In addition, the compiler
|
|
// inserts a J instruction (targeting the successor basic block), which
|
|
// accounts for another 4 bytes. Finally, an additional J instruction may
|
|
// appear (adding 4 more bytes) when the C.NOP is referenced elsewhere (ie.
|
|
// another branch).
|
|
#define print_possible_return_addresses(addr) \
|
|
printf("%" PRIu64 ": current_address=%p or %p\n", \
|
|
ompt_get_thread_data()->value, ((char *)addr) - 6, ((char *)addr) - 10)
|
|
#else
|
|
// On RV64G the NOP instruction is 4 byte long. In addition, the compiler
|
|
// inserts a J instruction (targeting the successor basic block), which
|
|
// accounts for another 4 bytes. Finally, an additional J instruction may
|
|
// appear (adding 4 more bytes) when the NOP is referenced elsewhere (ie.
|
|
// another branch).
|
|
#define print_possible_return_addresses(addr) \
|
|
printf("%" PRIu64 ": current_address=%p or %p\n", \
|
|
ompt_get_thread_data()->value, ((char *)addr) - 8, ((char *)addr) - 12)
|
|
#endif
|
|
#else
|
|
#error Unsupported target architecture, cannot determine address offset!
|
|
#endif
|
|
|
|
|
|
// This macro performs a somewhat similar job to print_current_address(), except
|
|
// that it discards a certain number of nibbles from the address and only prints
|
|
// the most significant bits / nibbles. This can be used for cases where the
|
|
// return address can only be approximated.
|
|
//
|
|
// To account for overflows (ie the most significant bits / nibbles have just
|
|
// changed as we are a few bytes above the relevant power of two) the addresses
|
|
// of the "current" and of the "previous block" are printed.
|
|
#define print_fuzzy_address(id) \
|
|
define_ompt_label(id) \
|
|
print_fuzzy_address_blocks(get_ompt_label_address(id))
|
|
|
|
// If you change this define you need to adapt all capture patterns in the tests
|
|
// to include or discard the new number of nibbles!
|
|
#define FUZZY_ADDRESS_DISCARD_NIBBLES 2
|
|
#define FUZZY_ADDRESS_DISCARD_BYTES (1 << ((FUZZY_ADDRESS_DISCARD_NIBBLES) * 4))
|
|
#define print_fuzzy_address_blocks(addr) \
|
|
printf("%" PRIu64 ": fuzzy_address=0x%" PRIx64 " or 0x%" PRIx64 \
|
|
" or 0x%" PRIx64 " or 0x%" PRIx64 " (%p)\n", \
|
|
ompt_get_thread_data()->value, \
|
|
((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES - 1, \
|
|
((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES, \
|
|
((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES + 1, \
|
|
((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES + 2, addr)
|
|
|
|
#define register_ompt_callback_t(name, type) \
|
|
do { \
|
|
type f_##name = &on_##name; \
|
|
if (ompt_set_callback(name, (ompt_callback_t)f_##name) == ompt_set_never) \
|
|
printf("0: Could not register callback '" #name "'\n"); \
|
|
} while (0)
|
|
|
|
#define register_ompt_callback(name) register_ompt_callback_t(name, name##_t)
|
|
|
|
#ifndef USE_PRIVATE_TOOL
|
|
static void
|
|
on_ompt_callback_mutex_acquire(
|
|
ompt_mutex_t kind,
|
|
unsigned int hint,
|
|
unsigned int impl,
|
|
ompt_wait_id_t wait_id,
|
|
const void *codeptr_ra)
|
|
{
|
|
switch(kind)
|
|
{
|
|
case ompt_mutex_lock:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_wait_lock: wait_id=%" PRIu64 ", hint=%" PRIu32
|
|
", impl=%" PRIu32 ", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_nest_lock:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_wait_nest_lock: wait_id=%" PRIu64 ", hint=%" PRIu32
|
|
", impl=%" PRIu32 ", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_critical:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_wait_critical: wait_id=%" PRIu64 ", hint=%" PRIu32
|
|
", impl=%" PRIu32 ", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_atomic:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_wait_atomic: wait_id=%" PRIu64 ", hint=%" PRIu32
|
|
", impl=%" PRIu32 ", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_ordered:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_wait_ordered: wait_id=%" PRIu64 ", hint=%" PRIu32
|
|
", impl=%" PRIu32 ", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_mutex_acquired(
|
|
ompt_mutex_t kind,
|
|
ompt_wait_id_t wait_id,
|
|
const void *codeptr_ra)
|
|
{
|
|
switch(kind)
|
|
{
|
|
case ompt_mutex_lock:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_acquired_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_nest_lock:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_acquired_nest_lock_first: wait_id=%" PRIu64
|
|
", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_critical:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_acquired_critical: wait_id=%" PRIu64
|
|
", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_atomic:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_acquired_atomic: wait_id=%" PRIu64
|
|
", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_ordered:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_acquired_ordered: wait_id=%" PRIu64
|
|
", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_mutex_released(
|
|
ompt_mutex_t kind,
|
|
ompt_wait_id_t wait_id,
|
|
const void *codeptr_ra)
|
|
{
|
|
switch(kind)
|
|
{
|
|
case ompt_mutex_lock:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_release_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_nest_lock:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_release_nest_lock_last: wait_id=%" PRIu64
|
|
", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_critical:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_release_critical: wait_id=%" PRIu64
|
|
", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_atomic:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_release_atomic: wait_id=%" PRIu64
|
|
", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_ordered:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_release_ordered: wait_id=%" PRIu64
|
|
", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_nest_lock(
|
|
ompt_scope_endpoint_t endpoint,
|
|
ompt_wait_id_t wait_id,
|
|
const void *codeptr_ra)
|
|
{
|
|
switch(endpoint)
|
|
{
|
|
case ompt_scope_begin:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_acquired_nest_lock_next: wait_id=%" PRIu64
|
|
", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
case ompt_scope_end:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_release_nest_lock_prev: wait_id=%" PRIu64
|
|
", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
case ompt_scope_beginend:
|
|
printf("ompt_scope_beginend should never be passed to %s\n", __func__);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_sync_region(
|
|
ompt_sync_region_t kind,
|
|
ompt_scope_endpoint_t endpoint,
|
|
ompt_data_t *parallel_data,
|
|
ompt_data_t *task_data,
|
|
const void *codeptr_ra)
|
|
{
|
|
switch(endpoint)
|
|
{
|
|
case ompt_scope_begin:
|
|
switch(kind)
|
|
{
|
|
case ompt_sync_region_barrier:
|
|
case ompt_sync_region_barrier_implicit:
|
|
case ompt_sync_region_barrier_implicit_workshare:
|
|
case ompt_sync_region_barrier_implicit_parallel:
|
|
case ompt_sync_region_barrier_teams:
|
|
case ompt_sync_region_barrier_explicit:
|
|
case ompt_sync_region_barrier_implementation:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_barrier_begin: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra);
|
|
print_ids(0);
|
|
break;
|
|
case ompt_sync_region_taskwait:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_taskwait_begin: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra);
|
|
break;
|
|
case ompt_sync_region_taskgroup:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_taskgroup_begin: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra);
|
|
break;
|
|
case ompt_sync_region_reduction:
|
|
printf("ompt_sync_region_reduction should never be passed to "
|
|
"on_ompt_callback_sync_region\n");
|
|
exit(-1);
|
|
break;
|
|
}
|
|
break;
|
|
case ompt_scope_end:
|
|
switch(kind)
|
|
{
|
|
case ompt_sync_region_barrier:
|
|
case ompt_sync_region_barrier_implicit:
|
|
case ompt_sync_region_barrier_explicit:
|
|
case ompt_sync_region_barrier_implicit_workshare:
|
|
case ompt_sync_region_barrier_implicit_parallel:
|
|
case ompt_sync_region_barrier_teams:
|
|
case ompt_sync_region_barrier_implementation:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_barrier_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value,
|
|
(parallel_data) ? parallel_data->value : 0, task_data->value,
|
|
codeptr_ra);
|
|
break;
|
|
case ompt_sync_region_taskwait:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_taskwait_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value,
|
|
(parallel_data) ? parallel_data->value : 0, task_data->value,
|
|
codeptr_ra);
|
|
break;
|
|
case ompt_sync_region_taskgroup:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_taskgroup_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value,
|
|
(parallel_data) ? parallel_data->value : 0, task_data->value,
|
|
codeptr_ra);
|
|
break;
|
|
case ompt_sync_region_reduction:
|
|
printf("ompt_sync_region_reduction should never be passed to "
|
|
"on_ompt_callback_sync_region\n");
|
|
exit(-1);
|
|
break;
|
|
}
|
|
break;
|
|
case ompt_scope_beginend:
|
|
printf("ompt_scope_beginend should never be passed to %s\n", __func__);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_sync_region_wait(
|
|
ompt_sync_region_t kind,
|
|
ompt_scope_endpoint_t endpoint,
|
|
ompt_data_t *parallel_data,
|
|
ompt_data_t *task_data,
|
|
const void *codeptr_ra)
|
|
{
|
|
switch(endpoint)
|
|
{
|
|
case ompt_scope_begin:
|
|
switch(kind)
|
|
{
|
|
case ompt_sync_region_barrier:
|
|
case ompt_sync_region_barrier_implicit:
|
|
case ompt_sync_region_barrier_implicit_workshare:
|
|
case ompt_sync_region_barrier_implicit_parallel:
|
|
case ompt_sync_region_barrier_teams:
|
|
case ompt_sync_region_barrier_explicit:
|
|
case ompt_sync_region_barrier_implementation:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_wait_barrier_begin: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra);
|
|
break;
|
|
case ompt_sync_region_taskwait:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_wait_taskwait_begin: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra);
|
|
break;
|
|
case ompt_sync_region_taskgroup:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_wait_taskgroup_begin: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra);
|
|
break;
|
|
case ompt_sync_region_reduction:
|
|
printf("ompt_sync_region_reduction should never be passed to "
|
|
"on_ompt_callback_sync_region_wait\n");
|
|
exit(-1);
|
|
break;
|
|
}
|
|
break;
|
|
case ompt_scope_end:
|
|
switch(kind)
|
|
{
|
|
case ompt_sync_region_barrier:
|
|
case ompt_sync_region_barrier_implicit:
|
|
case ompt_sync_region_barrier_implicit_workshare:
|
|
case ompt_sync_region_barrier_implicit_parallel:
|
|
case ompt_sync_region_barrier_teams:
|
|
case ompt_sync_region_barrier_explicit:
|
|
case ompt_sync_region_barrier_implementation:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_wait_barrier_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value,
|
|
(parallel_data) ? parallel_data->value : 0, task_data->value,
|
|
codeptr_ra);
|
|
break;
|
|
case ompt_sync_region_taskwait:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_wait_taskwait_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value,
|
|
(parallel_data) ? parallel_data->value : 0, task_data->value,
|
|
codeptr_ra);
|
|
break;
|
|
case ompt_sync_region_taskgroup:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_wait_taskgroup_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value,
|
|
(parallel_data) ? parallel_data->value : 0, task_data->value,
|
|
codeptr_ra);
|
|
break;
|
|
case ompt_sync_region_reduction:
|
|
printf("ompt_sync_region_reduction should never be passed to "
|
|
"on_ompt_callback_sync_region_wait\n");
|
|
exit(-1);
|
|
break;
|
|
}
|
|
break;
|
|
case ompt_scope_beginend:
|
|
printf("ompt_scope_beginend should never be passed to %s\n", __func__);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
static void on_ompt_callback_reduction(ompt_sync_region_t kind,
|
|
ompt_scope_endpoint_t endpoint,
|
|
ompt_data_t *parallel_data,
|
|
ompt_data_t *task_data,
|
|
const void *codeptr_ra) {
|
|
switch (endpoint) {
|
|
case ompt_scope_begin:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_reduction_begin: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value,
|
|
(parallel_data) ? parallel_data->value : 0, task_data->value,
|
|
codeptr_ra);
|
|
break;
|
|
case ompt_scope_end:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_reduction_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value,
|
|
(parallel_data) ? parallel_data->value : 0, task_data->value,
|
|
codeptr_ra);
|
|
break;
|
|
case ompt_scope_beginend:
|
|
printf("ompt_scope_beginend should never be passed to %s\n", __func__);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_flush(
|
|
ompt_data_t *thread_data,
|
|
const void *codeptr_ra)
|
|
{
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX " ompt_event_flush: codeptr_ra=%p\n",
|
|
thread_data->value, codeptr_ra);
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_cancel(
|
|
ompt_data_t *task_data,
|
|
int flags,
|
|
const void *codeptr_ra)
|
|
{
|
|
const char* first_flag_value;
|
|
const char* second_flag_value;
|
|
if(flags & ompt_cancel_parallel)
|
|
first_flag_value = ompt_cancel_flag_t_values[0];
|
|
else if(flags & ompt_cancel_sections)
|
|
first_flag_value = ompt_cancel_flag_t_values[1];
|
|
else if(flags & ompt_cancel_loop)
|
|
first_flag_value = ompt_cancel_flag_t_values[2];
|
|
else if(flags & ompt_cancel_taskgroup)
|
|
first_flag_value = ompt_cancel_flag_t_values[3];
|
|
|
|
if(flags & ompt_cancel_activated)
|
|
second_flag_value = ompt_cancel_flag_t_values[4];
|
|
else if(flags & ompt_cancel_detected)
|
|
second_flag_value = ompt_cancel_flag_t_values[5];
|
|
else if(flags & ompt_cancel_discarded_task)
|
|
second_flag_value = ompt_cancel_flag_t_values[6];
|
|
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX " ompt_event_cancel: task_data=%" PRIu64
|
|
", flags=%s|%s=%" PRIu32 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value, task_data->value, first_flag_value,
|
|
second_flag_value, flags, codeptr_ra);
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_implicit_task(
|
|
ompt_scope_endpoint_t endpoint,
|
|
ompt_data_t *parallel_data,
|
|
ompt_data_t *task_data,
|
|
unsigned int team_size,
|
|
unsigned int thread_num,
|
|
int flags)
|
|
{
|
|
switch(endpoint)
|
|
{
|
|
case ompt_scope_begin:
|
|
if(task_data->ptr)
|
|
printf("%s\n", "0: task_data initially not null");
|
|
task_data->value = ompt_get_unique_id();
|
|
|
|
//there is no parallel_begin callback for implicit parallel region
|
|
//thus it is initialized in initial task
|
|
if(flags & ompt_task_initial)
|
|
{
|
|
char buffer[2048];
|
|
|
|
format_task_type(flags, buffer);
|
|
// Only check initial task not created by teams construct
|
|
if (team_size == 1 && thread_num == 1 && parallel_data->ptr)
|
|
printf("%s\n", "0: parallel_data initially not null");
|
|
parallel_data->value = ompt_get_unique_id();
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_initial_task_begin: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", actual_parallelism=%" PRIu32
|
|
", index=%" PRIu32 ", flags=%" PRIu32 "\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, team_size, thread_num, flags);
|
|
} else {
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_implicit_task_begin: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", team_size=%" PRIu32
|
|
", thread_num=%" PRIu32 "\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, team_size, thread_num);
|
|
}
|
|
|
|
break;
|
|
case ompt_scope_end:
|
|
if(flags & ompt_task_initial){
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_initial_task_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", actual_parallelism=%" PRIu32
|
|
", index=%" PRIu32 "\n",
|
|
ompt_get_thread_data()->value,
|
|
(parallel_data) ? parallel_data->value : 0, task_data->value,
|
|
team_size, thread_num);
|
|
} else {
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_implicit_task_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", team_size=%" PRIu32
|
|
", thread_num=%" PRIu32 "\n",
|
|
ompt_get_thread_data()->value,
|
|
(parallel_data) ? parallel_data->value : 0, task_data->value,
|
|
team_size, thread_num);
|
|
}
|
|
break;
|
|
case ompt_scope_beginend:
|
|
printf("ompt_scope_beginend should never be passed to %s\n", __func__);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_lock_init(
|
|
ompt_mutex_t kind,
|
|
unsigned int hint,
|
|
unsigned int impl,
|
|
ompt_wait_id_t wait_id,
|
|
const void *codeptr_ra)
|
|
{
|
|
switch(kind)
|
|
{
|
|
case ompt_mutex_lock:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_init_lock: wait_id=%" PRIu64 ", hint=%" PRIu32
|
|
", impl=%" PRIu32 ", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_nest_lock:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_init_nest_lock: wait_id=%" PRIu64 ", hint=%" PRIu32
|
|
", impl=%" PRIu32 ", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_lock_destroy(
|
|
ompt_mutex_t kind,
|
|
ompt_wait_id_t wait_id,
|
|
const void *codeptr_ra)
|
|
{
|
|
switch(kind)
|
|
{
|
|
case ompt_mutex_lock:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_destroy_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
case ompt_mutex_nest_lock:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_destroy_nest_lock: wait_id=%" PRIu64
|
|
", codeptr_ra=%p \n",
|
|
ompt_get_thread_data()->value, wait_id, codeptr_ra);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_work(
|
|
ompt_work_t wstype,
|
|
ompt_scope_endpoint_t endpoint,
|
|
ompt_data_t *parallel_data,
|
|
ompt_data_t *task_data,
|
|
uint64_t count,
|
|
const void *codeptr_ra)
|
|
{
|
|
switch(endpoint)
|
|
{
|
|
case ompt_scope_begin:
|
|
switch(wstype)
|
|
{
|
|
case ompt_work_loop:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_loop_begin: parallel_id=%" PRIu64
|
|
", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
|
|
"\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_sections:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_sections_begin: parallel_id=%" PRIu64
|
|
", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
|
|
"\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_single_executor:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_single_in_block_begin: parallel_id=%" PRIu64
|
|
", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
|
|
"\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_single_other:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_single_others_begin: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_workshare:
|
|
//impl
|
|
break;
|
|
case ompt_work_distribute:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_distribute_begin: parallel_id=%" PRIu64
|
|
", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
|
|
"\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_taskloop:
|
|
//impl
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_taskloop_begin: parallel_id=%" PRIu64
|
|
", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
|
|
"\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_scope:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_scope_begin: parallel_id=%" PRIu64
|
|
", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
|
|
"\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
}
|
|
break;
|
|
case ompt_scope_end:
|
|
switch(wstype)
|
|
{
|
|
case ompt_work_loop:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_loop_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_sections:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_sections_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_single_executor:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_single_in_block_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_single_other:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_single_others_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_workshare:
|
|
//impl
|
|
break;
|
|
case ompt_work_distribute:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_distribute_end: parallel_id=%" PRIu64
|
|
", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
|
|
"\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_taskloop:
|
|
//impl
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_taskloop_end: parallel_id=%" PRIu64
|
|
", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
|
|
"\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
case ompt_work_scope:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_scope_end: parallel_id=%" PRIu64
|
|
", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64
|
|
"\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra, count);
|
|
break;
|
|
}
|
|
break;
|
|
case ompt_scope_beginend:
|
|
printf("ompt_scope_beginend should never be passed to %s\n", __func__);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
static void on_ompt_callback_masked(ompt_scope_endpoint_t endpoint,
|
|
ompt_data_t *parallel_data,
|
|
ompt_data_t *task_data,
|
|
const void *codeptr_ra) {
|
|
switch(endpoint)
|
|
{
|
|
case ompt_scope_begin:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_masked_begin: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra);
|
|
break;
|
|
case ompt_scope_end:
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_masked_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64
|
|
", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value, parallel_data->value,
|
|
task_data->value, codeptr_ra);
|
|
break;
|
|
case ompt_scope_beginend:
|
|
printf("ompt_scope_beginend should never be passed to %s\n", __func__);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
static void on_ompt_callback_parallel_begin(
|
|
ompt_data_t *encountering_task_data,
|
|
const ompt_frame_t *encountering_task_frame, ompt_data_t *parallel_data,
|
|
uint32_t requested_team_size, int flag, const void *codeptr_ra) {
|
|
if(parallel_data->ptr)
|
|
printf("0: parallel_data initially not null\n");
|
|
parallel_data->value = ompt_get_unique_id();
|
|
int invoker = flag & 0xF;
|
|
const char *event = (flag & ompt_parallel_team) ? "parallel" : "teams";
|
|
const char *size = (flag & ompt_parallel_team) ? "team_size" : "num_teams";
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_%s_begin: parent_task_id=%" PRIu64
|
|
", parent_task_frame.exit=%p, parent_task_frame.reenter=%p, "
|
|
"parallel_id=%" PRIu64 ", requested_%s=%" PRIu32
|
|
", codeptr_ra=%p, invoker=%d\n",
|
|
ompt_get_thread_data()->value, event, encountering_task_data->value,
|
|
encountering_task_frame->exit_frame.ptr,
|
|
encountering_task_frame->enter_frame.ptr, parallel_data->value, size,
|
|
requested_team_size, codeptr_ra, invoker);
|
|
}
|
|
|
|
static void on_ompt_callback_parallel_end(ompt_data_t *parallel_data,
|
|
ompt_data_t *encountering_task_data,
|
|
int flag, const void *codeptr_ra) {
|
|
int invoker = flag & 0xF;
|
|
const char *event = (flag & ompt_parallel_team) ? "parallel" : "teams";
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX " ompt_event_%s_end: parallel_id=%" PRIu64
|
|
", task_id=%" PRIu64 ", invoker=%d, codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value, event, parallel_data->value,
|
|
encountering_task_data->value, invoker, codeptr_ra);
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_task_create(
|
|
ompt_data_t *encountering_task_data,
|
|
const ompt_frame_t *encountering_task_frame,
|
|
ompt_data_t* new_task_data,
|
|
int type,
|
|
int has_dependences,
|
|
const void *codeptr_ra)
|
|
{
|
|
if(new_task_data->ptr)
|
|
printf("0: new_task_data initially not null\n");
|
|
new_task_data->value = ompt_get_unique_id();
|
|
char buffer[2048];
|
|
|
|
format_task_type(type, buffer);
|
|
|
|
printf(
|
|
"%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_task_create: parent_task_id=%" PRIu64
|
|
", parent_task_frame.exit=%p, parent_task_frame.reenter=%p, "
|
|
"new_task_id=%" PRIu64
|
|
", codeptr_ra=%p, task_type=%s=%d, has_dependences=%s\n",
|
|
ompt_get_thread_data()->value,
|
|
encountering_task_data ? encountering_task_data->value : 0,
|
|
encountering_task_frame ? encountering_task_frame->exit_frame.ptr : NULL,
|
|
encountering_task_frame ? encountering_task_frame->enter_frame.ptr : NULL,
|
|
new_task_data->value, codeptr_ra, buffer, type,
|
|
has_dependences ? "yes" : "no");
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_task_schedule(
|
|
ompt_data_t *first_task_data,
|
|
ompt_task_status_t prior_task_status,
|
|
ompt_data_t *second_task_data)
|
|
{
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_task_schedule: first_task_id=%" PRIu64
|
|
", second_task_id=%" PRIu64 ", prior_task_status=%s=%d\n",
|
|
ompt_get_thread_data()->value, first_task_data->value,
|
|
(second_task_data ? second_task_data->value : -1),
|
|
ompt_task_status_t_values[prior_task_status], prior_task_status);
|
|
if (prior_task_status == ompt_task_complete ||
|
|
prior_task_status == ompt_task_late_fulfill) {
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX " ompt_event_task_end: task_id=%" PRIu64
|
|
"\n", ompt_get_thread_data()->value, first_task_data->value);
|
|
}
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_dependences(
|
|
ompt_data_t *task_data,
|
|
const ompt_dependence_t *deps,
|
|
int ndeps)
|
|
{
|
|
char buffer[2048];
|
|
char *progress = buffer;
|
|
for (int i = 0; i < ndeps && progress < buffer + 2000; i++) {
|
|
if (deps[i].dependence_type == ompt_dependence_type_source ||
|
|
deps[i].dependence_type == ompt_dependence_type_sink)
|
|
progress +=
|
|
sprintf(progress, "(%" PRIu64 ", %s), ", deps[i].variable.value,
|
|
ompt_dependence_type_t_values[deps[i].dependence_type]);
|
|
else
|
|
progress +=
|
|
sprintf(progress, "(%p, %s), ", deps[i].variable.ptr,
|
|
ompt_dependence_type_t_values[deps[i].dependence_type]);
|
|
}
|
|
if (ndeps > 0)
|
|
progress[-2] = 0;
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX " ompt_event_dependences: task_id=%" PRIu64
|
|
", deps=[%s], ndeps=%d\n",
|
|
ompt_get_thread_data()->value, task_data->value, buffer, ndeps);
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_task_dependence(
|
|
ompt_data_t *first_task_data,
|
|
ompt_data_t *second_task_data)
|
|
{
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_task_dependence_pair: first_task_id=%" PRIu64
|
|
", second_task_id=%" PRIu64 "\n",
|
|
ompt_get_thread_data()->value, first_task_data->value,
|
|
second_task_data->value);
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_thread_begin(
|
|
ompt_thread_t thread_type,
|
|
ompt_data_t *thread_data)
|
|
{
|
|
if(thread_data->ptr)
|
|
printf("%s\n", "0: thread_data initially not null");
|
|
thread_data->value = ompt_get_unique_id();
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX
|
|
" ompt_event_thread_begin: thread_type=%s=%d, thread_id=%" PRIu64 "\n",
|
|
ompt_get_thread_data()->value, ompt_thread_t_values[thread_type],
|
|
thread_type, thread_data->value);
|
|
}
|
|
|
|
static void
|
|
on_ompt_callback_thread_end(
|
|
ompt_data_t *thread_data)
|
|
{
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX " ompt_event_thread_end: thread_id=%" PRIu64
|
|
"\n",
|
|
ompt_get_thread_data()->value, thread_data->value);
|
|
}
|
|
|
|
static int
|
|
on_ompt_callback_control_tool(
|
|
uint64_t command,
|
|
uint64_t modifier,
|
|
void *arg,
|
|
const void *codeptr_ra)
|
|
{
|
|
ompt_frame_t* omptTaskFrame;
|
|
ompt_get_task_info(0, NULL, (ompt_data_t**) NULL, &omptTaskFrame, NULL, NULL);
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX " ompt_event_control_tool: command=%" PRIu64
|
|
", modifier=%" PRIu64
|
|
", arg=%p, codeptr_ra=%p, current_task_frame.exit=%p, "
|
|
"current_task_frame.reenter=%p \n",
|
|
ompt_get_thread_data()->value, command, modifier, arg, codeptr_ra,
|
|
omptTaskFrame->exit_frame.ptr, omptTaskFrame->enter_frame.ptr);
|
|
|
|
// the following would interfere with expected output for OMPT tests, so skip
|
|
#ifndef _OMPT_TESTS
|
|
// print task data
|
|
int task_level = 0;
|
|
ompt_data_t *task_data;
|
|
while (ompt_get_task_info(task_level, NULL, (ompt_data_t **)&task_data, NULL,
|
|
NULL, NULL)) {
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX " task level %d: task_id=%" PRIu64 "\n",
|
|
ompt_get_thread_data()->value, task_level, task_data->value);
|
|
task_level++;
|
|
}
|
|
|
|
// print parallel data
|
|
int parallel_level = 0;
|
|
ompt_data_t *parallel_data;
|
|
while (ompt_get_parallel_info(parallel_level, (ompt_data_t **)¶llel_data,
|
|
NULL)) {
|
|
printf("%" PRIu64 ":" _TOOL_PREFIX " parallel level %d: parallel_id=%" PRIu64
|
|
"\n",
|
|
ompt_get_thread_data()->value, parallel_level, parallel_data->value);
|
|
parallel_level++;
|
|
}
|
|
#endif
|
|
return 0; //success
|
|
}
|
|
|
|
static void on_ompt_callback_error(ompt_severity_t severity,
|
|
const char *message, size_t length,
|
|
const void *codeptr_ra) {
|
|
printf("%" PRIu64 ": ompt_event_runtime_error: severity=%" PRIu32
|
|
", message=%s, length=%" PRIu64 ", codeptr_ra=%p\n",
|
|
ompt_get_thread_data()->value, severity, message, (uint64_t)length,
|
|
codeptr_ra);
|
|
}
|
|
|
|
int ompt_initialize(
|
|
ompt_function_lookup_t lookup,
|
|
int initial_device_num,
|
|
ompt_data_t *tool_data)
|
|
{
|
|
ompt_set_callback = (ompt_set_callback_t) lookup("ompt_set_callback");
|
|
ompt_get_callback = (ompt_get_callback_t) lookup("ompt_get_callback");
|
|
ompt_get_state = (ompt_get_state_t) lookup("ompt_get_state");
|
|
ompt_get_task_info = (ompt_get_task_info_t) lookup("ompt_get_task_info");
|
|
ompt_get_task_memory = (ompt_get_task_memory_t)lookup("ompt_get_task_memory");
|
|
ompt_get_thread_data = (ompt_get_thread_data_t) lookup("ompt_get_thread_data");
|
|
ompt_get_parallel_info = (ompt_get_parallel_info_t) lookup("ompt_get_parallel_info");
|
|
ompt_get_unique_id = (ompt_get_unique_id_t) lookup("ompt_get_unique_id");
|
|
ompt_finalize_tool = (ompt_finalize_tool_t)lookup("ompt_finalize_tool");
|
|
|
|
ompt_get_unique_id();
|
|
|
|
ompt_get_num_procs = (ompt_get_num_procs_t) lookup("ompt_get_num_procs");
|
|
ompt_get_num_places = (ompt_get_num_places_t) lookup("ompt_get_num_places");
|
|
ompt_get_place_proc_ids = (ompt_get_place_proc_ids_t) lookup("ompt_get_place_proc_ids");
|
|
ompt_get_place_num = (ompt_get_place_num_t) lookup("ompt_get_place_num");
|
|
ompt_get_partition_place_nums = (ompt_get_partition_place_nums_t) lookup("ompt_get_partition_place_nums");
|
|
ompt_get_proc_id = (ompt_get_proc_id_t) lookup("ompt_get_proc_id");
|
|
ompt_enumerate_states = (ompt_enumerate_states_t) lookup("ompt_enumerate_states");
|
|
ompt_enumerate_mutex_impls = (ompt_enumerate_mutex_impls_t) lookup("ompt_enumerate_mutex_impls");
|
|
|
|
register_ompt_callback(ompt_callback_mutex_acquire);
|
|
register_ompt_callback_t(ompt_callback_mutex_acquired, ompt_callback_mutex_t);
|
|
register_ompt_callback_t(ompt_callback_mutex_released, ompt_callback_mutex_t);
|
|
register_ompt_callback(ompt_callback_nest_lock);
|
|
register_ompt_callback(ompt_callback_sync_region);
|
|
register_ompt_callback_t(ompt_callback_sync_region_wait, ompt_callback_sync_region_t);
|
|
register_ompt_callback_t(ompt_callback_reduction, ompt_callback_sync_region_t);
|
|
register_ompt_callback(ompt_callback_control_tool);
|
|
register_ompt_callback(ompt_callback_flush);
|
|
register_ompt_callback(ompt_callback_cancel);
|
|
register_ompt_callback(ompt_callback_implicit_task);
|
|
register_ompt_callback_t(ompt_callback_lock_init, ompt_callback_mutex_acquire_t);
|
|
register_ompt_callback_t(ompt_callback_lock_destroy, ompt_callback_mutex_t);
|
|
register_ompt_callback(ompt_callback_work);
|
|
register_ompt_callback(ompt_callback_masked);
|
|
register_ompt_callback(ompt_callback_parallel_begin);
|
|
register_ompt_callback(ompt_callback_parallel_end);
|
|
register_ompt_callback(ompt_callback_task_create);
|
|
register_ompt_callback(ompt_callback_task_schedule);
|
|
register_ompt_callback(ompt_callback_dependences);
|
|
register_ompt_callback(ompt_callback_task_dependence);
|
|
register_ompt_callback(ompt_callback_thread_begin);
|
|
register_ompt_callback(ompt_callback_thread_end);
|
|
register_ompt_callback(ompt_callback_error);
|
|
printf("0: NULL_POINTER=%p\n", (void*)NULL);
|
|
return 1; //success
|
|
}
|
|
|
|
void ompt_finalize(ompt_data_t *tool_data)
|
|
{
|
|
printf("0: ompt_event_runtime_shutdown\n");
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
ompt_start_tool_result_t* ompt_start_tool(
|
|
unsigned int omp_version,
|
|
const char *runtime_version)
|
|
{
|
|
static ompt_start_tool_result_t ompt_start_tool_result = {&ompt_initialize,&ompt_finalize, 0};
|
|
return &ompt_start_tool_result;
|
|
}
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif // ifndef USE_PRIVATE_TOOL
|
|
#ifdef _OMPT_TESTS
|
|
#undef _OMPT_TESTS
|
|
#endif
|