[OpenMP] [OMPD] [1/6] Implementation of OMPD debugging library - libompd. Code changes in openmp/runtime to support libompd.

[Vigneshbalu]

Summary

These patches propose the implementation of OMPD, a debugging interface to support debugging of OpenMP programs.

"libompd.so" acts as an interface to the third-party tools, typically the debuggers. The tool accesses the state of the OpenMP program through the library and libompd can read or write the state of the OpenMP program that has begun execution through the callback function provided by the tool.

A brief talk regarding the upstreaming plans was provided a few months back in the LLVM-OpenMP committee meeting, the notes of which were provided at:
https://docs.google.com/document/d/1OeibmJ41dndC7xqVFNHwfLJx3hM5uFErBrsmp2nrV2w/edit?usp=sharing

Most of the implementation has been contributed to by folks from RWTH-Aachen University, LLNL, Rice University, Perforce, AMD and others. (Might have missed out some of the contributors – apologies for that). It has been developed and maintained in https://github.com/OpenMPToolsInterface/llvm-project/tree/ompd-tests/openmp

OMPD support is restricted only to CPU and Linux currently.

OMPD APIs are implemented as per the OpenMP 5.0 standard https://www.openmp.org/wp-content/uploads/OpenMP-API-Specification-5.0.pdf .
These patches also include some gdb-plugin code which is a python module which can be loaded into the debugger, gdb. This provides OMPD specific debugging commands once the "ompd init" command is invoked at the gdb prompt. More details regarding this are provided in the README available in the gdb-plugin directory.

CMake build system and directory structure are similar to the openmp/runtime and openmp/libomptarget.
Testing is done by two methods. First by comparing the output of OMPT and OMPD, second through gdb-plugin using llvm-lit and Filecheck.

This implementation does not provide debugging support for offloading to CPUs or GPUs.

The breakdown of patches is below.
Note: Patches should be applied in the below order.

1. Code changes in openmp/runtime to support libompd.
2. TargetValue: Access OpenMP runtime state through callbacks provided by the tool.
3. omp-debug: Implementation of OMPD APIs.
4. omp-icv: OMPD Internal control variable handlers.
5. gdb-plugin: A Plugin code to gdb to leverage libompd to provide debugging support.
6. libompd-tests: Testcases for libompd.

Another set of around 50 testcases will be pushed subsequently.

Please let me know if the patches need to be reorganized.

[jdoerfert]

Can you please upload a diff with full context, see (https://llvm.org/docs/Phabricator.html#phabricator-request-review-web).

openmp/runtime/src/kmp_csupport.cpp

644

Here and elsewhere, if a change is not guarded by OMPD_SUPPORT, it seems to me they should be committed separately.

[Vigneshbalu]

Diff with full context

[Vigneshbalu]

openmp/runtime/src/kmp_csupport.cpp

644

I have guarded other places, this change and "openmp/runtime/src/ompt-specific.cpp" are code movement that stems from https://github.com/OpenMPToolsInterface/llvm-project/commit/45e69d3a5fc27af7bf92ed5310987eb25070e538 .
I will create separate review for this.

[Vigneshbalu]

Removed the code that is not guarded by OMPD and created a separate review for the same https://reviews.llvm.org/D100366

[Vigneshbalu]

Addressed clang-tidy warnings.

[hbae]

openmp/runtime/src/include/omp-tools.h.var

1307

We need to use ompd_wait_id_t.

openmp/runtime/src/kmp_runtime.cpp

1343

Why do we need scheduling task for implicit tasks while we don't call it task scheduling in the specification?

2034

We already have program points defined for OMPT callbacks.
Isn't it better to place parallel begin/end BP at the places near OMPT parallel begin/end?
Are there any missing parallel begin/end not covered by the current OMPT parallel begin/end?

openmp/runtime/src/ompd-specific.cpp

41

Can you add some comments why it is 7.

[jini.susan]

openmp/runtime/src/include/omp-tools.h.var

1307

Thanks for this good catch! Will work on modifying this.

openmp/runtime/src/kmp_runtime.cpp

2034

According to the spec, there is a difference in the binding associated with the current parallel handle with the OMPT parallel-begin event and the OMPD parallel-begin event.

For OMPD, (Section 5.6.1.)

The OpenMP implementation must execute ompd_bp_parallel_begin at every
parallel-begin event. At the point that the implementation reaches
ompd_bp_parallel_begin, the binding for ompd_get_curr_parallel_handle is the
parallel region that is beginning and the binding for ompd_get_curr_task_handle is the
task that encountered the parallel construct.

For OMPT,

Between a parallel-begin event and an implicit-task-begin event, a call to
ompt_get_parallel_info(0,...) may return information about the outer parallel team,
the new parallel team or an inconsistent state.

The OMPD runtime entry points in this implementation are invoked at points to ensure that the right binding holds as per the spec.

[protze.joachim]

openmp/runtime/src/kmp_runtime.cpp

2034

The OMPT parallel-begin is placed before the runtime gets a lock for creating the team. All information provided by the callback is available at this point. Other information like the number of threads is passed in the implicit-task-begin event.
As Jini pointed out, there is not enough information available for OMPD parallel-begin at that point.

openmp/runtime/src/ompd-specific.h

127–128

Please drop these lines. The current patches don't include any cuda stuff.

157

same here, drop the cuda symbol

[Vigneshbalu]

Addressed the Review comments.

[Vigneshbalu]

openmp/runtime/src/ompd-specific.cpp

41

Thanks Hansang. it is unwanted variable and removed it

openmp/runtime/src/ompd-specific.h

127–128

Done

157

Thanks for the catch joachim

[protze.joachim]

openmp/runtime/src/kmp_runtime.cpp

1343

I think, the specification of ompd_get_scheduling_task_handle and ompd_get_generating_task_handle needs some refinement.

I think, the background here is the following:

On return, the scheduling_task_handle argument points to a location that points to a handle for the
task that is still on the stack of execution on the same thread and was deferred in favor of executing
the selected task.

When reaching a taskwait, the execution of the encountering implicit task is deferred to execute some explicit tasks.
Similarly, for a parallel region, the execution of the encountering implicit task is deferred to execute the implicit task of the parallel region.

When thinking about possible debugger workflow, it might help to cut the chain as you suggest and implicitly tell the debugger, that the implicit task is reached and the debugger should use ompd_get_generating_task_handle to get the parent task on the stack.

For the function ompd_get_generating_task_handle, the following might be an issue:

The ompd_get_generating_task_handle function obtains a pointer to the task handle for the task that encountered the OpenMP task construct that generated the task represented by task_handle.

Since the parallel construct is no task construct, following this definition, the task encountering a parallel construct is also not the generating task. The glossary entry for generating task also refers to the parallel region and not the implicit task.

I think, we should clarify the terms in the next tools subcommittee call.

[protze.joachim]

openmp/runtime/src/kmp_runtime.cpp

1343

As of today's OMPD discussion, we will add a clarification for 5.2, that implicit tasks have no scheduling parent task, but all tasks have a generating parent task.
Unwinding the stack of explicit tasks, a tool would be able to identify when an implicit task is reached and can look at the generating task to further unwind the stack of tasks.

This means, all assignments of scheduling_parent should be removed in this function.

[Vigneshbalu]

Removing assignments of scheduling_parent from the function "__kmp_fork_call" as per review comment.

[hbae]

openmp/runtime/src/kmp_runtime.cpp

1344

Is there any reason to keep this for serialized parallel?

[Vigneshbalu]

openmp/runtime/src/kmp_runtime.cpp

1344

Apologies for the oversight, removed the wrong assignments. Working on the changes, will update the diff.

[hbae]

openmp/runtime/src/kmp_runtime.cpp

1344

I think other changes are OK. This one is also need to be removed.

[Vigneshbalu]

Addressed review comments.

[Vigneshbalu]

openmp/runtime/src/kmp_runtime.cpp

1344

Removed and updated the diff, please let us know if there is any other review comments.

[hbae]

LGTM

[ronlieb]

I am seeing intermittent failures with the new test case on our amdgpu buildbot

FAIL: ompd-test::ompd_parallel.c

https://lab.llvm.org/buildbot/#/builders/193/builds/21594

please revert and fix.

[ye-luo]

I disabled the test
test/CMakeLists.txt breaks DeviceRTL in LLVM_ENABLE_PROJECTS builds.
find_package(LLVM) is likely the source of the trouble.

openmp/runtime/CMakeLists.txt

 
 # TSAN-support
 set(LIBOMP_TSAN_SUPPORT FALSE CACHE BOOL
   "TSAN-support?")
 if(LIBOMP_TSAN_SUPPORT AND (NOT LIBOMP_HAVE_TSAN_SUPPORT))
   libomp_error_say("TSAN functionality requested but not available")
 endif()
 
+# OMPD-support
+# Enable if OMPT SUPPORT is ON
+set(OMPD_DEFAULT FALSE)
+if (LIBOMP_HAVE_OMPT_SUPPORT AND ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux"))
+  set(OMPD_DEFAULT TRUE)
+endif()
+
+set(LIBOMP_OMPD_SUPPORT ${OMPD_DEFAULT} CACHE BOOL
+  "OMPD-support?")
+
+if(LIBOMP_OMPD_SUPPORT AND ((NOT LIBOMP_OMPT_SUPPORT) OR (NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")))
+  libomp_error_say("OpenMP Debug Interface(OMPD) requested but not available in this implementation")
+endif()
+
 # Error check hwloc support after config-ix has run
 if(LIBOMP_USE_HWLOC AND (NOT LIBOMP_HAVE_HWLOC))
   libomp_error_say("Hwloc requested but not available")
 endif()
 
 # Hierarchical scheduling support
 set(LIBOMP_USE_HIER_SCHED FALSE CACHE BOOL
   "Hierarchical scheduling support?")
if(${OPENMP_STANDALONE_BUILD})
   libomp_say("Build                -- ${LIBOMP_BUILD}")
   libomp_say("Use Stats-gathering  -- ${LIBOMP_STATS}")
   libomp_say("Use Debugger-support -- ${LIBOMP_USE_DEBUGGER}")
   libomp_say("Use ITT notify       -- ${LIBOMP_USE_ITT_NOTIFY}")
   libomp_say("Use OMPT-support     -- ${LIBOMP_OMPT_SUPPORT}")
   if(${LIBOMP_OMPT_SUPPORT})
     libomp_say("Use OMPT-optional  -- ${LIBOMP_OMPT_OPTIONAL}")
   endif()
+  libomp_say("Use OMPD-support     -- ${LIBOMP_OMPD_SUPPORT}")
   libomp_say("Use Adaptive locks   -- ${LIBOMP_USE_ADAPTIVE_LOCKS}")
   libomp_say("Use quad precision   -- ${LIBOMP_USE_QUAD_PRECISION}")
   libomp_say("Use TSAN-support     -- ${LIBOMP_TSAN_SUPPORT}")
   libomp_say("Use Hwloc library    -- ${LIBOMP_USE_HWLOC}")
 endif()
 
 add_subdirectory(src)
 add_subdirectory(test)
 
 # make these variables available for tools:
 set(LIBOMP_LIBRARY_DIR ${LIBOMP_LIBRARY_DIR} PARENT_SCOPE)
 set(LIBOMP_INCLUDE_DIR ${LIBOMP_INCLUDE_DIR} PARENT_SCOPE)
+# make these variables available for tools/libompd:
+set(LIBOMP_SRC_DIR ${LIBOMP_SRC_DIR} PARENT_SCOPE)

openmp/runtime/src/CMakeLists.txt

else()
   libomp_append(LIBOMP_CXXFILES kmp_cancel.cpp)
 endif()
 # Files common to stubs and normal library
 libomp_append(LIBOMP_CXXFILES kmp_ftn_cdecl.cpp)
 libomp_append(LIBOMP_CXXFILES kmp_ftn_extra.cpp)
 libomp_append(LIBOMP_CXXFILES kmp_version.cpp)
 libomp_append(LIBOMP_CXXFILES ompt-general.cpp IF_TRUE LIBOMP_OMPT_SUPPORT)
 libomp_append(LIBOMP_CXXFILES tsan_annotations.cpp IF_TRUE LIBOMP_TSAN_SUPPORT)
+libomp_append(LIBOMP_CXXFILES ompd-specific.cpp IF_TRUE LIBOMP_OMPD_SUPPORT)
 
 set(LIBOMP_SOURCE_FILES ${LIBOMP_CXXFILES} ${LIBOMP_ASMFILES})
 # For Windows, there is a resource file (.rc -> .res) that is also compiled
 libomp_append(LIBOMP_SOURCE_FILES libomp.rc WIN32)
 
 # Get compiler and assembler flags
 libomp_get_cxxflags(LIBOMP_CONFIGURED_CXXFLAGS)
 libomp_get_asmflags(LIBOMP_CONFIGURED_ASMFLAGS)
if(NOT WIN32)
   add_custom_command(TARGET omp POST_BUILD
     COMMAND ${CMAKE_COMMAND} -E create_symlink ${LIBOMP_LIB_FILE}
       libgomp${LIBOMP_LIBRARY_SUFFIX}
     COMMAND ${CMAKE_COMMAND} -E create_symlink ${LIBOMP_LIB_FILE}
       libiomp5${LIBOMP_LIBRARY_SUFFIX}
     WORKING_DIRECTORY ${LIBOMP_LIBRARY_DIR}
   )
 endif()
+set(LIBOMP_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR} PARENT_SCOPE)
 
 # Create *.inc before compiling any sources
 # objects depend on : .inc files
 add_custom_target(libomp-needed-headers DEPENDS kmp_i18n_id.inc kmp_i18n_default.inc)
 add_dependencies(omp libomp-needed-headers)
 
 # Windows specific build rules
 if(WIN32)
   configure_file(libomp.rc.var libomp.rc @ONLY)
 
   # Create .def and .rc file before compiling any sources
   add_custom_target(libomp-needed-windows-files DEPENDS ${LIBOMP_LIB_NAME}.def)
   add_dependencies(omp libomp-needed-windows-files)
   # z_Windows_NT-586_asm.asm requires definitions to be sent via command line
   # It only needs the architecture macro and OMPT_SUPPORT=0|1
   libomp_append(LIBOMP_MASM_DEFINITIONS "-D_M_IA32" IF_TRUE IA32)
   libomp_append(LIBOMP_MASM_DEFINITIONS "-D_M_AMD64" IF_TRUE INTEL64)
   libomp_append(LIBOMP_MASM_DEFINITIONS "-DOMPT_SUPPORT" IF_TRUE_1_0 LIBOMP_OMPT_SUPPORT)
+  libomp_append(LIBOMP_MASM_DEFINITIONS "-DOMPD_SUPPORT" IF_TRUE_1_0 LIBOMP_OMPD_SUPPORT)
   libomp_list_to_string("${LIBOMP_MASM_DEFINITIONS}" LIBOMP_MASM_DEFINITIONS)
   set_property(SOURCE z_Windows_NT-586_asm.asm APPEND_STRING PROPERTY COMPILE_FLAGS " ${LIBOMP_MASM_DEFINITIONS}")
   set_source_files_properties(thirdparty/ittnotify/ittnotify_static.cpp PROPERTIES COMPILE_DEFINITIONS "UNICODE")
 
   # Create Windows import library
   # the import library is "re-linked" to include kmp_import.cpp which prevents
   # linking of both Visual Studio OpenMP and newly built OpenMP
   set_source_files_properties(kmp_import.cpp PROPERTIES COMPILE_FLAGS "${LIBOMP_CONFIGURED_CXXFLAGS}")

openmp/runtime/src/include/omp-tools.h.var

typedef enum ompd_rc_t {
   ompd_rc_bad_input = 3,
   ompd_rc_error = 4,
   ompd_rc_unsupported = 5,
   ompd_rc_needs_state_tracking = 6,
   ompd_rc_incompatible = 7,
   ompd_rc_device_read_error = 8,
   ompd_rc_device_write_error = 9,
   ompd_rc_nomem = 10,
+  ompd_rc_incomplete = 11,
+  ompd_rc_callback_error = 12
 } ompd_rc_t;
 
 typedef void (*ompt_interface_fn_t) (void);
 
 typedef ompt_interface_fn_t (*ompt_function_lookup_t) (
   const char *interface_function_name
 );
 
typedef struct ompd_device_type_sizes_t {
   uint8_t sizeof_char;
   uint8_t sizeof_short;
   uint8_t sizeof_int;
   uint8_t sizeof_long;
   uint8_t sizeof_long_long;
   uint8_t sizeof_pointer;
 } ompd_device_type_sizes_t;
 
+void ompd_dll_locations_valid(void);
+
+typedef ompd_rc_t (*ompd_callback_memory_alloc_fn_t)(ompd_size_t nbytes,
+                                                     void **ptr);
+
+typedef ompd_rc_t (*ompd_callback_memory_free_fn_t)(void *ptr);
+
+typedef ompd_rc_t (*ompd_callback_get_thread_context_for_thread_id_fn_t)(
+    ompd_address_space_context_t *address_space_context, ompd_thread_id_t kind,
+    ompd_size_t sizeof_thread_id, const void *thread_id,
+    ompd_thread_context_t **thread_context);
+
+typedef ompd_rc_t (*ompd_callback_sizeof_fn_t)(
+    ompd_address_space_context_t *address_space_context,
+    ompd_device_type_sizes_t *sizes);
+
+typedef ompd_rc_t (*ompd_callback_symbol_addr_fn_t)(
+    ompd_address_space_context_t *address_space_context,
+    ompd_thread_context_t *thread_context, const char *symbol_name,
+    ompd_address_t *symbol_addr, const char *file_name);
+
+typedef ompd_rc_t (*ompd_callback_memory_read_fn_t)(
+    ompd_address_space_context_t *address_space_context,
+    ompd_thread_context_t *thread_context, const ompd_address_t *addr,
+    ompd_size_t nbytes, void *buffer);
+
+typedef ompd_rc_t (*ompd_callback_memory_write_fn_t)(
+    ompd_address_space_context_t *address_space_context,
+    ompd_thread_context_t *thread_context, const ompd_address_t *addr,
+    ompd_size_t nbytes, const void *buffer);
+
+typedef ompd_rc_t (*ompd_callback_device_host_fn_t)(
+    ompd_address_space_context_t *address_space_context, const void *input,
+    ompd_size_t unit_size, ompd_size_t count, void *output);
+
+typedef ompd_rc_t (*ompd_callback_print_string_fn_t)(const char *string,
+                                                     int category);
+
+typedef struct ompd_callbacks_t {
+  ompd_callback_memory_alloc_fn_t alloc_memory;
+  ompd_callback_memory_free_fn_t free_memory;
+  ompd_callback_print_string_fn_t print_string;
+  ompd_callback_sizeof_fn_t sizeof_type;
+  ompd_callback_symbol_addr_fn_t symbol_addr_lookup;
+  ompd_callback_memory_read_fn_t read_memory;
+  ompd_callback_memory_write_fn_t write_memory;
+  ompd_callback_memory_read_fn_t read_string;
+  ompd_callback_device_host_fn_t device_to_host;
+  ompd_callback_device_host_fn_t host_to_device;
+  ompd_callback_get_thread_context_for_thread_id_fn_t
+      get_thread_context_for_thread_id;
+} ompd_callbacks_t;
+
+void ompd_bp_parallel_begin(void);
+
+void ompd_bp_parallel_end(void);
+
+void ompd_bp_task_begin(void);
+
+void ompd_bp_task_end(void);
+
+void ompd_bp_thread_begin(void);
+
+void ompd_bp_thread_end(void);
+
+void ompd_bp_device_begin(void);
+
+void ompd_bp_device_end(void);
+
+ompd_rc_t ompd_initialize(ompd_word_t api_version,
+                          const ompd_callbacks_t *callbacks);
+
+ompd_rc_t ompd_get_api_version(ompd_word_t *version);
+
+ompd_rc_t ompd_get_version_string(const char **string);
+
+ompd_rc_t ompd_finalize(void);
+
+ompd_rc_t ompd_process_initialize(ompd_address_space_context_t *context,
+                                  ompd_address_space_handle_t **handle);
+
+ompd_rc_t ompd_device_initialize(ompd_address_space_handle_t *process_handle,
+                                 ompd_address_space_context_t *device_context,
+                                 ompd_device_t kind, ompd_size_t sizeof_id,
+                                 void *id,
+                                 ompd_address_space_handle_t **device_handle);
+
+ompd_rc_t ompd_rel_address_space_handle(ompd_address_space_handle_t *handle);
+
+ompd_rc_t ompd_get_omp_version(ompd_address_space_handle_t *address_space,
+                               ompd_word_t *omp_version);
+
+ompd_rc_t
+ompd_get_omp_version_string(ompd_address_space_handle_t *address_space,
+                            const char **string);
+
+ompd_rc_t ompd_get_thread_in_parallel(ompd_parallel_handle_t *parallel_handle,
+                                      int thread_num,
+                                      ompd_thread_handle_t **thread_handle);
+
+ompd_rc_t ompd_get_thread_handle(ompd_address_space_handle_t *handle,
+                                 ompd_thread_id_t kind,
+                                 ompd_size_t sizeof_thread_id,
+                                 const void *thread_id,
+                                 ompd_thread_handle_t **thread_handle);
+
+ompd_rc_t ompd_rel_thread_handle(ompd_thread_handle_t *thread_handle);
+
+ompd_rc_t ompd_thread_handle_compare(ompd_thread_handle_t *thread_handle_1,
+                                     ompd_thread_handle_t *thread_handle_2,
+                                     int *cmp_value);
+
+ompd_rc_t ompd_get_thread_id(ompd_thread_handle_t *thread_handle,
+                             ompd_thread_id_t kind,
+                             ompd_size_t sizeof_thread_id, void *thread_id);
+
+ompd_rc_t
+ompd_get_curr_parallel_handle(ompd_thread_handle_t *thread_handle,
+                              ompd_parallel_handle_t **parallel_handle);
+
+ompd_rc_t ompd_get_enclosing_parallel_handle(
+    ompd_parallel_handle_t *parallel_handle,
+    ompd_parallel_handle_t **enclosing_parallel_handle);
+
+ompd_rc_t
+ompd_get_task_parallel_handle(ompd_task_handle_t *task_handle,
+                              ompd_parallel_handle_t **task_parallel_handle);
+
+ompd_rc_t ompd_rel_parallel_handle(ompd_parallel_handle_t *parallel_handle);
+
+ompd_rc_t
+ompd_parallel_handle_compare(ompd_parallel_handle_t *parallel_handle_1,
+                             ompd_parallel_handle_t *parallel_handle_2,
+                             int *cmp_value);
+
+ompd_rc_t ompd_get_curr_task_handle(ompd_thread_handle_t *thread_handle,
+                                    ompd_task_handle_t **task_handle);
+
+ompd_rc_t
+ompd_get_generating_task_handle(ompd_task_handle_t *task_handle,
+                                ompd_task_handle_t **generating_task_handle);
+
+ompd_rc_t
+ompd_get_scheduling_task_handle(ompd_task_handle_t *task_handle,
+                                ompd_task_handle_t **scheduling_task_handle);
+
+ompd_rc_t ompd_get_task_in_parallel(ompd_parallel_handle_t *parallel_handle,
+                                    int thread_num,
+                                    ompd_task_handle_t **task_handle);
+
+ompd_rc_t ompd_rel_task_handle(ompd_task_handle_t *task_handle);
+
+ompd_rc_t ompd_task_handle_compare(ompd_task_handle_t *task_handle_1,
+                                   ompd_task_handle_t *task_handle_2,
+                                   int *cmp_value);
+
+ompd_rc_t ompd_get_task_function(ompd_task_handle_t *task_handle,
+                                 ompd_address_t *entry_point);
+
+ompd_rc_t ompd_get_task_frame(ompd_task_handle_t *task_handle,
+                              ompd_frame_info_t *exit_frame,
+                              ompd_frame_info_t *enter_frame);
+
+ompd_rc_t
+ompd_enumerate_states(ompd_address_space_handle_t *address_space_handle,
+                      ompd_word_t current_state, ompd_word_t *next_state,
+                      const char **next_state_name, ompd_word_t *more_enums);
+
+ompd_rc_t ompd_get_state(ompd_thread_handle_t *thread_handle,
+                         ompd_word_t *state, ompd_wait_id_t *wait_id);
+
+ompd_rc_t
+ompd_get_display_control_vars(ompd_address_space_handle_t *address_space_handle,
+                              const char *const **control_vars);
+
+ompd_rc_t ompd_rel_display_control_vars(const char *const **control_vars);
+
+ompd_rc_t ompd_enumerate_icvs(ompd_address_space_handle_t *handle,
+                              ompd_icv_id_t current, ompd_icv_id_t *next_id,
+                              const char **next_icv_name,
+                              ompd_scope_t *next_scope, int *more);
+
+ompd_rc_t ompd_get_icv_from_scope(void *handle, ompd_scope_t scope,
+                                  ompd_icv_id_t icv_id, ompd_word_t *icv_value);
+
+ompd_rc_t ompd_get_icv_string_from_scope(void *handle, ompd_scope_t scope,
+                                         ompd_icv_id_t icv_id,
+                                         const char **icv_string);
+
+ompd_rc_t ompd_get_tool_data(void *handle, ompd_scope_t scope,
+                             ompd_word_t *value, ompd_address_t *ptr);
+
 typedef struct ompt_record_ompt_t {
   ompt_callbacks_t type;
   ompt_device_time_t time;
   ompt_id_t thread_id;
   ompt_id_t target_id;
   union {
     ompt_record_thread_begin_t thread_begin;
     ompt_record_parallel_begin_t parallel_begin;

openmp/runtime/src/kmp.h

 #if KMP_OS_LINUX
 #pragma weak clock_gettime
 #endif
 
 #if OMPT_SUPPORT
 #include "ompt-internal.h"
 #endif
 
+#if OMPD_SUPPORT
+#include "ompd-specific.h"
+#endif
+
 #ifndef UNLIKELY
 #define UNLIKELY(x) (x)
 #endif
 
 // Affinity format function
 #include "kmp_str.h"
 
 // 0 - no fast memory allocation, alignment: 8-byte on x86, 16-byte on x64.
typedef struct kmp_nested_proc_bind_t {
   int used;
 } kmp_nested_proc_bind_t;
 
 extern kmp_nested_proc_bind_t __kmp_nested_proc_bind;
 
 extern int __kmp_display_affinity;
 extern char *__kmp_affinity_format;
 static const size_t KMP_AFFINITY_FORMAT_SIZE = 512;
+#if OMPT_SUPPORT
+extern int __kmp_tool;
+extern char *__kmp_tool_libraries;
+#endif // OMPT_SUPPORT
 
 #if KMP_AFFINITY_SUPPORTED
 #define KMP_PLACE_ALL (-1)
 #define KMP_PLACE_UNDEFINED (-2)
 // Is KMP_AFFINITY is being used instead of OMP_PROC_BIND/OMP_PLACES?
 #define KMP_AFFINITY_NON_PROC_BIND                                             \
   ((__kmp_nested_proc_bind.bind_types[0] == proc_bind_false ||                 \
     __kmp_nested_proc_bind.bind_types[0] == proc_bind_intel) &&                \

openmp/runtime/src/kmp_config.h.cmake

 #cmakedefine01 LIBOMP_HAVE___RDTSC
 #define KMP_HAVE___RDTSC LIBOMP_HAVE___RDTSC
 #cmakedefine01 LIBOMP_USE_DEBUGGER
 #define USE_DEBUGGER LIBOMP_USE_DEBUGGER
 #cmakedefine01 LIBOMP_OMPT_DEBUG
 #define OMPT_DEBUG LIBOMP_OMPT_DEBUG
 #cmakedefine01 LIBOMP_OMPT_SUPPORT
 #define OMPT_SUPPORT LIBOMP_OMPT_SUPPORT
+#cmakedefine01 LIBOMP_OMPD_SUPPORT
+#define OMPD_SUPPORT LIBOMP_OMPD_SUPPORT
 #cmakedefine01 LIBOMP_PROFILING_SUPPORT
 #define OMP_PROFILING_SUPPORT LIBOMP_PROFILING_SUPPORT
 #cmakedefine01 LIBOMP_OMPT_OPTIONAL
 #define OMPT_OPTIONAL LIBOMP_OMPT_OPTIONAL
 #cmakedefine01 LIBOMP_USE_ADAPTIVE_LOCKS
 #define KMP_USE_ADAPTIVE_LOCKS LIBOMP_USE_ADAPTIVE_LOCKS
 #define KMP_DEBUG_ADAPTIVE_LOCKS 0
 #cmakedefine01 LIBOMP_USE_INTERNODE_ALIGNMENT

openmp/runtime/src/kmp_csupport.cpp

 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
     if (__kmp_inherit_fp_control && serial_team->t.t_fp_control_saved) {
       __kmp_clear_x87_fpu_status_word();
       __kmp_load_x87_fpu_control_word(&serial_team->t.t_x87_fpu_control_word);
       __kmp_load_mxcsr(&serial_team->t.t_mxcsr);
     }
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
+#if OMPD_SUPPORT
+    if (ompd_state & OMPD_ENABLE_BP)
+      ompd_bp_parallel_end();
+#endif
+
     this_thr->th.th_team = serial_team->t.t_parent;
     this_thr->th.th_info.ds.ds_tid = serial_team->t.t_master_tid;
 
     /* restore values cached in the thread */
     this_thr->th.th_team_nproc = serial_team->t.t_parent->t.t_nproc; /*  JPH */
     this_thr->th.th_team_master =
         serial_team->t.t_parent->t.t_threads[0]; /* JPH */
     this_thr->th.th_team_serialized = this_thr->th.th_team->t.t_serialized;
if (__kmp_tasking_mode != tskm_immediate_exec) {
                 "team %p\n",
                 global_tid, this_thr->th.th_task_team, this_thr->th.th_team));
     }
   } else {
     if (__kmp_tasking_mode != tskm_immediate_exec) {
       KA_TRACE(20, ("__kmpc_end_serialized_parallel: T#%d decreasing nesting "
                     "depth of serial team %p to %d\n",
                     global_tid, serial_team, serial_team->t.t_serialized));
     }
   }
 
   if (__kmp_env_consistency_check)
     __kmp_pop_parallel(global_tid, NULL);
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled)
     this_thr->th.ompt_thread_info.state =
         ((this_thr->th.th_team_serialized) ? ompt_state_work_serial

openmp/runtime/src/kmp_gsupport.cpp

__kmp_GOMP_fork_call(&loc, gtid, num_threads, 0u, task,
                        (microtask_t)__kmp_GOMP_microtask_wrapper, 2, task,
                        data);
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &frame, NULL, NULL);
     frame->exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
   }
 #endif
+#if OMPD_SUPPORT
+  if (ompd_state & OMPD_ENABLE_BP)
+    ompd_bp_parallel_begin();
+#endif
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_END)(void) {
   int gtid = __kmp_get_gtid();
   kmp_info_t *thr;
 
   thr = __kmp_threads[gtid];
 

 #endif
 
   __kmp_join_call(&loc, gtid
 #if OMPT_SUPPORT
                   ,
                   fork_context_gnu
 #endif
   );
+#if OMPD_SUPPORT
+  if (ompd_state & OMPD_ENABLE_BP)
+    ompd_bp_parallel_end();
+#endif
 }
 
 // Loop worksharing constructs
 
 // The Gnu codegen passes in an exclusive upper bound for the overall range,
 // but the libguide dispatch code expects an inclusive upper bound, hence the
 // "end - incr" 5th argument to KMP_DISPATCH_INIT (and the " ub - str" 11th
 // argument to __kmp_GOMP_fork_call).

openmp/runtime/src/kmp_runtime.cpp

 #include "kmp_dispatch.h"
 #if KMP_USE_HIER_SCHED
 #include "kmp_dispatch_hier.h"
 #endif
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"
 #endif
+#if OMPD_SUPPORT
+#include "ompd-specific.h"
+#endif
 
 #if OMP_PROFILING_SUPPORT
 #include "llvm/Support/TimeProfiler.h"
 static char *ProfileTraceFile = nullptr;
 #endif
 
 /* these are temporary issues to be dealt with */
 #define KMP_USE_PRCTL 0
if (ompt_enabled.ompt_callback_implicit_task) {
       OMPT_CUR_TASK_INFO(this_thr)->thread_num =
           __kmp_tid_from_gtid(global_tid);
     }
 
     /* OMPT state */
     this_thr->th.ompt_thread_info.state = ompt_state_work_parallel;
     OMPT_CUR_TASK_INFO(this_thr)->frame.exit_frame.ptr =
         OMPT_GET_FRAME_ADDRESS(0);
   }
 #endif
 }
 
 /* most of the work for a fork */
 /* return true if we really went parallel, false if serialized */
 int __kmp_fork_call(ident_t *loc, int gtid,
                     enum fork_context_e call_context, // Intel, GNU, ...
                     kmp_int32 argc, microtask_t microtask, launch_t invoker,
                     kmp_va_list ap) {
if (master_th->th.th_teams_microtask && ap &&
 
         if (call_context == fork_context_gnu) {
           // AC: need to decrement t_serialized for enquiry functions to work
           // correctly, will restore at join time
           parent_team->t.t_serialized--;
           return TRUE;
         }
 
+#if OMPD_SUPPORT
+        parent_team->t.t_pkfn = microtask;
+#endif
+
 #if OMPT_SUPPORT
         void *dummy;
         void **exit_frame_p;
 
         ompt_lw_taskteam_t lw_taskteam;
 
         if (ompt_enabled.enabled) {
           __ompt_lw_taskteam_init(&lw_taskteam, master_th, gtid,

 #endif /* KMP_OS_LINUX && ( KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || \
           KMP_ARCH_AARCH64) */
 
       KA_TRACE(20,
                ("__kmp_fork_call: T#%d serializing parallel region\n", gtid));
 
       __kmpc_serialized_parallel(loc, gtid);
 
+#if OMPD_SUPPORT
+      master_th->th.th_serial_team->t.t_pkfn = microtask;
+#endif
+
       if (call_context == fork_context_intel) {
         /* TODO this sucks, use the compiler itself to pass args! :) */
         master_th->th.th_serial_team->t.t_ident = loc;
         if (!ap) {
           // revert change made in __kmpc_serialized_parallel()
           master_th->th.th_serial_team->t.t_level--;
           // Get args from parent team for teams construct
 
#endif
     // set primary thread's schedule as new run-time schedule
     KMP_CHECK_UPDATE(team->t.t_sched.sched, new_sched.sched);
 
     KMP_CHECK_UPDATE(team->t.t_cancel_request, cancel_noreq);
     KMP_CHECK_UPDATE(team->t.t_def_allocator, master_th->th.th_def_allocator);
 
     // Update the floating point rounding in the team if required.
     propagateFPControl(team);
+#if OMPD_SUPPORT
+    if (ompd_state & OMPD_ENABLE_BP)
+      ompd_bp_parallel_begin();
+#endif
 
     if (__kmp_tasking_mode != tskm_immediate_exec) {
       // Set primary thread's task team to team's task team. Unless this is hot
       // team, it should be NULL.
       KMP_DEBUG_ASSERT(master_th->th.th_task_team ==
                        parent_team->t.t_task_team[master_th->th.th_task_state]);
       KA_TRACE(20, ("__kmp_fork_call: Primary T#%d pushing task_team %p / team "
                     "%p, new task_team %p / team %p\n",
#if KMP_STATS_ENABLED
   }
 #endif
 
   KA_TRACE(20, ("__kmp_fork_call: T#%d(%d:0) done microtask = %p\n", gtid,
                 team->t.t_id, team->t.t_pkfn));
   KMP_MB(); /* Flush all pending memory write invalidates.  */
 
   KA_TRACE(20, ("__kmp_fork_call: parallel exit T#%d\n", gtid));
-
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled) {
     master_th->th.ompt_thread_info.state = ompt_state_overhead;
   }
 #endif
 
   return TRUE;
 }

 
 #if KMP_AFFINITY_SUPPORTED
   // Restore master thread's partition.
   master_th->th.th_first_place = team->t.t_first_place;
   master_th->th.th_last_place = team->t.t_last_place;
 #endif // KMP_AFFINITY_SUPPORTED
   master_th->th.th_def_allocator = team->t.t_def_allocator;
 
+#if OMPD_SUPPORT
+  if (ompd_state & OMPD_ENABLE_BP)
+    ompd_bp_parallel_end();
+#endif
   updateHWFPControl(team);
 
   if (root->r.r_active != master_active)
     root->r.r_active = master_active;
 
   __kmp_free_team(root, team USE_NESTED_HOT_ARG(
                             master_th)); // this will free worker threads
 
if (!initial_thread && ompt_enabled.enabled) {
     if (ompt_enabled.ompt_callback_implicit_task) {
       ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
           ompt_scope_begin, parallel_data, task_data, 1, 1, ompt_task_initial);
     }
 
     ompt_set_thread_state(root_thread, ompt_state_work_serial);
   }
 #endif
+#if OMPD_SUPPORT
+  if (ompd_state & OMPD_ENABLE_BP)
+    ompd_bp_thread_begin();
+#endif
 
   KMP_MB();
   __kmp_release_bootstrap_lock(&__kmp_forkjoin_lock);
 
   return gtid;
 }
 
 #if KMP_NESTED_HOT_TEAMS
#if KMP_OS_WINDOWS
   KA_TRACE(
       10, ("__kmp_reset_root: free handle, th = %p, handle = %" KMP_UINTPTR_SPEC
            "\n",
            (LPVOID) & (root->r.r_uber_thread->th),
            root->r.r_uber_thread->th.th_info.ds.ds_thread));
   __kmp_free_handle(root->r.r_uber_thread->th.th_info.ds.ds_thread);
 #endif /* KMP_OS_WINDOWS */
 
+#if OMPD_SUPPORT
+  if (ompd_state & OMPD_ENABLE_BP)
+    ompd_bp_thread_end();
+#endif
+
 #if OMPT_SUPPORT
   ompt_data_t *task_data;
   ompt_data_t *parallel_data;
   __ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data,
                                 NULL);
   if (ompt_enabled.ompt_callback_implicit_task) {
     ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
         ompt_scope_end, parallel_data, task_data, 0, 1, ompt_task_initial);
#endif
 
   KMP_MB();
   KA_TRACE(10, ("__kmp_launch_thread: T#%d start\n", gtid));
 
   if (__kmp_env_consistency_check) {
     this_thr->th.th_cons = __kmp_allocate_cons_stack(gtid); // ATT: Memory leak?
   }
 
+#if OMPD_SUPPORT
+  if (ompd_state & OMPD_ENABLE_BP)
+    ompd_bp_thread_begin();
+#endif
+
 #if OMPT_SUPPORT
   ompt_data_t *thread_data = nullptr;
   if (ompt_enabled.enabled) {
     thread_data = &(this_thr->th.ompt_thread_info.thread_data);
     *thread_data = ompt_data_none;
 
     this_thr->th.ompt_thread_info.state = ompt_state_overhead;
     this_thr->th.ompt_thread_info.wait_id = 0;
#if OMPT_SUPPORT
       }
 #endif
       /* join barrier after parallel region */
       __kmp_join_barrier(gtid);
     }
   }
   TCR_SYNC_PTR((intptr_t)__kmp_global.g.g_done);
 
+#if OMPD_SUPPORT
+  if (ompd_state & OMPD_ENABLE_BP)
+    ompd_bp_thread_end();
+#endif
+
 #if OMPT_SUPPORT
   if (ompt_enabled.ompt_callback_thread_end) {
     ompt_callbacks.ompt_callback(ompt_callback_thread_end)(thread_data);
   }
 #endif
 
   this_thr->th.th_task_team = NULL;
   /* run the destructors for the threadprivate data for this thread */
static void __kmp_do_serial_initialize(void) {
   KMP_DEBUG_ASSERT(sizeof(kmp_uint32) == 4);
   KMP_DEBUG_ASSERT(sizeof(kmp_int64) == 8);
   KMP_DEBUG_ASSERT(sizeof(kmp_uint64) == 8);
   KMP_DEBUG_ASSERT(sizeof(kmp_intptr_t) == sizeof(void *));
 
 #if OMPT_SUPPORT
   ompt_pre_init();
 #endif
+#if OMPD_SUPPORT
+  __kmp_env_dump();
+  ompd_init();
+#endif
 
   __kmp_validate_locks();
 
   /* Initialize internal memory allocator */
   __kmp_init_allocator();
 
   /* Register the library startup via an environment variable and check to see
      whether another copy of the library is already registered. */
#endif /* KMP_AFFINITY_SUPPORTED */
   __kmp_root = NULL;
   __kmp_threads_capacity = 0;
 
 #if KMP_USE_DYNAMIC_LOCK
   __kmp_cleanup_indirect_user_locks();
 #else
   __kmp_cleanup_user_locks();
 #endif
+#if OMPD_SUPPORT
+  if (ompd_state) {
+    __kmp_free(ompd_env_block);
+    ompd_env_block = NULL;
+    ompd_env_block_size = 0;
+  }
+#endif
 
 #if KMP_AFFINITY_SUPPORTED
   KMP_INTERNAL_FREE(CCAST(char *, __kmp_cpuinfo_file));
   __kmp_cpuinfo_file = NULL;
 #endif /* KMP_AFFINITY_SUPPORTED */
 
 #if KMP_USE_ADAPTIVE_LOCKS
 #if KMP_DEBUG_ADAPTIVE_LOCKS

openmp/runtime/src/kmp_settings.h

 #ifndef KMP_SETTINGS_H
 #define KMP_SETTINGS_H
 
 void __kmp_reset_global_vars(void);
 void __kmp_env_initialize(char const *);
 void __kmp_env_print();
 void __kmp_env_print_2();
 void __kmp_display_env_impl(int display_env, int display_env_verbose);
+#if OMPD_SUPPORT
+void __kmp_env_dump();
+#endif
 
 int __kmp_initial_threads_capacity(int req_nproc);
 void __kmp_init_dflt_team_nth();
 int __kmp_convert_to_milliseconds(char const *);
 int __kmp_default_tp_capacity(int, int, int);
 
 #if KMP_MIC
 #define KMP_STR_BUF_PRINT_NAME                                                 \

openmp/runtime/src/kmp_settings.cpp

 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_lock.h"
 #include "kmp_settings.h"
 #include "kmp_str.h"
 #include "kmp_wrapper_getpid.h"
 #include <ctype.h> // toupper()
+#if OMPD_SUPPORT
+#include "ompd-specific.h"
+#endif
 
 static int __kmp_env_toPrint(char const *name, int flag);
 
 bool __kmp_env_format = 0; // 0 - old format; 1 - new format
 
 // -----------------------------------------------------------------------------
 // Helper string functions. Subject to move to kmp_str.
 

 } // __kmp_stg_parse_omp_cancellation
 
 static void __kmp_stg_print_omp_cancellation(kmp_str_buf_t *buffer,
                                              char const *name, void *data) {
   __kmp_stg_print_bool(buffer, name, __kmp_omp_cancellation);
 } // __kmp_stg_print_omp_cancellation
 
 #if OMPT_SUPPORT
-static int __kmp_tool = 1;
+int __kmp_tool = 1;
 
 static void __kmp_stg_parse_omp_tool(char const *name, char const *value,
                                      void *data) {
   __kmp_stg_parse_bool(name, value, &__kmp_tool);
 } // __kmp_stg_parse_omp_tool
 
 static void __kmp_stg_print_omp_tool(kmp_str_buf_t *buffer, char const *name,
                                      void *data) {
   if (__kmp_env_format) {
     KMP_STR_BUF_PRINT_BOOL_EX(name, __kmp_tool, "enabled", "disabled");
   } else {
     __kmp_str_buf_print(buffer, "   %s=%s\n", name,
                         __kmp_tool ? "enabled" : "disabled");
   }
 } // __kmp_stg_print_omp_tool
 
-static char *__kmp_tool_libraries = NULL;
+char *__kmp_tool_libraries = NULL;
 
 static void __kmp_stg_parse_omp_tool_libraries(char const *name,
                                                char const *value, void *data) {
   __kmp_stg_parse_str(name, value, &__kmp_tool_libraries);
 } // __kmp_stg_parse_omp_tool_libraries
 
 static void __kmp_stg_print_omp_tool_libraries(kmp_str_buf_t *buffer,
                                                char const *name, void *data) {
   if (__kmp_tool_libraries)
     __kmp_stg_print_str(buffer, name, __kmp_tool_libraries);
   else {
     if (__kmp_env_format) {
       KMP_STR_BUF_PRINT_NAME;
     } else {
       __kmp_str_buf_print(buffer, "   %s", name);
     }
     __kmp_str_buf_print(buffer, ": %s\n", KMP_I18N_STR(NotDefined));
   }
 } // __kmp_stg_print_omp_tool_libraries
 
-static char *__kmp_tool_verbose_init = NULL;
+char *__kmp_tool_verbose_init = NULL;
 
 static void __kmp_stg_parse_omp_tool_verbose_init(char const *name,
                                                   char const *value,
                                                   void *data) {
   __kmp_stg_parse_str(name, value, &__kmp_tool_verbose_init);
 } // __kmp_stg_parse_omp_tool_libraries
 
 static void __kmp_stg_print_omp_tool_verbose_init(kmp_str_buf_t *buffer,
void __kmp_display_env_impl(int display_env, int display_env_verbose) {
   __kmp_printf("%s", buffer.str);
 
   __kmp_env_blk_free(&block);
   __kmp_str_buf_free(&buffer);
 
   __kmp_printf("\n");
 }
 
+#if OMPD_SUPPORT
+// Dump environment variables for OMPD
+void __kmp_env_dump() {
+
+  kmp_env_blk_t block;
+  kmp_str_buf_t buffer, env, notdefined;
+
+  __kmp_stg_init();
+  __kmp_str_buf_init(&buffer);
+  __kmp_str_buf_init(&env);
+  __kmp_str_buf_init(&notdefined);
+
+  __kmp_env_blk_init(&block, NULL);
+  __kmp_env_blk_sort(&block);
+
+  __kmp_str_buf_print(&notdefined, ": %s", KMP_I18N_STR(NotDefined));
+
+  for (int i = 0; i < __kmp_stg_count; ++i) {
+    if (__kmp_stg_table[i].print == NULL)
+      continue;
+    __kmp_str_buf_clear(&env);
+    __kmp_stg_table[i].print(&env, __kmp_stg_table[i].name,
+                             __kmp_stg_table[i].data);
+    if (env.used < 4) // valid definition must have indents (3) and a new line
+      continue;
+    if (strstr(env.str, notdefined.str))
+      // normalize the string
+      __kmp_str_buf_print(&buffer, "%s=undefined\n", __kmp_stg_table[i].name);
+    else
+      __kmp_str_buf_cat(&buffer, env.str + 3, env.used - 3);
+  }
+
+  ompd_env_block = (char *)__kmp_allocate(buffer.used + 1);
+  KMP_MEMCPY(ompd_env_block, buffer.str, buffer.used + 1);
+  ompd_env_block_size = (ompd_size_t)KMP_STRLEN(ompd_env_block);
+
+  __kmp_env_blk_free(&block);
+  __kmp_str_buf_free(&buffer);
+  __kmp_str_buf_free(&env);
+  __kmp_str_buf_free(&notdefined);
+}
+#endif // OMPD_SUPPORT
+
 // end of file

openmp/runtime/src/kmp_tasking.cpp

 #endif // KMP_STATS_ENABLED
 
 // OMPT task begin
 #if OMPT_SUPPORT
     if (UNLIKELY(ompt_enabled.enabled))
       __ompt_task_start(task, current_task, gtid);
 #endif
 
+#if OMPD_SUPPORT
+    if (ompd_state & OMPD_ENABLE_BP)
+      ompd_bp_task_begin();
+#endif
+
 #if USE_ITT_BUILD && USE_ITT_NOTIFY
     kmp_uint64 cur_time;
     kmp_int32 kmp_itt_count_task =
         __kmp_forkjoin_frames_mode == 3 && !taskdata->td_flags.task_serial &&
         current_task->td_flags.tasktype == TASK_IMPLICIT;
     if (kmp_itt_count_task) {
       thread = __kmp_threads[gtid];
       // Time outer level explicit task on barrier for adjusting imbalance time
if (kmp_itt_count_task) {
       // Barrier imbalance - adjust arrive time with the task duration
       thread->th.th_bar_arrive_time += (__itt_get_timestamp() - cur_time);
     }
     KMP_FSYNC_CANCEL(taskdata); // destroy self (just executed)
     KMP_FSYNC_RELEASING(taskdata->td_parent); // releasing parent
 #endif
   }
 
+#if OMPD_SUPPORT
+  if (ompd_state & OMPD_ENABLE_BP)
+    ompd_bp_task_end();
+#endif
+
   // Proxy tasks are not handled by the runtime
   if (taskdata->td_flags.proxy != TASK_PROXY) {
     ANNOTATE_HAPPENS_BEFORE(taskdata->td_parent);
 #if OMPT_SUPPORT
     if (UNLIKELY(ompt_enabled.enabled)) {
       thread->th.ompt_thread_info = oldInfo;
       if (taskdata->td_flags.tiedness == TASK_TIED) {
         taskdata->ompt_task_info.frame.exit_frame = ompt_data_none;

openmp/runtime/src/kmp_wait_release.h

public:
   void suspend(int th_gtid) { __kmp_suspend_oncore(th_gtid, this); }
 #if KMP_HAVE_MWAIT || KMP_HAVE_UMWAIT
   void mwait(int th_gtid) { __kmp_mwait_oncore(th_gtid, this); }
 #endif
   void resume(int th_gtid) { __kmp_resume_oncore(th_gtid, this); }
   int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin,
                     int *thread_finished USE_ITT_BUILD_ARG(void *itt_sync_obj),
                     kmp_int32 is_constrained) {
+#if OMPD_SUPPORT
+    int ret = __kmp_execute_tasks_oncore(
+        this_thr, gtid, this, final_spin,
+        thread_finished USE_ITT_BUILD_ARG(itt_sync_obj), is_constrained);
+    if (ompd_state & OMPD_ENABLE_BP)
+      ompd_bp_task_end();
+    return ret;
+#else
     return __kmp_execute_tasks_oncore(
         this_thr, gtid, this, final_spin,
         thread_finished USE_ITT_BUILD_ARG(itt_sync_obj), is_constrained);
+#endif
   }
   kmp_uint8 *get_stolen() { return NULL; }
   enum barrier_type get_bt() { return bt; }
   flag_type get_ptr_type() { return flag_oncore; }
 };
 
 // Used to wake up threads, volatile void* flag is usually the th_sleep_loc
 // associated with int gtid.

openmp/runtime/src/ompd-specific.h

+/*
+ * ompd-specific.h -- OpenMP debug support
+ */
+
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "kmp.h"
+#include "omp-tools.h"
+#include <stdint.h>
+
+#ifndef __OMPD_SPECIFIC_H__
+#define __OMPD_SPECIFIC_H__
+
+#if OMPD_SUPPORT
+
+void ompd_init();
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern char *ompd_env_block;
+extern ompd_size_t ompd_env_block_size;
+extern char *__kmp_tool_verbose_init;
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+extern uint64_t ompd_state;
+#define OMPD_ENABLE_BP 0x1
+
+#define OMPD_FOREACH_ACCESS(OMPD_ACCESS)                                       \
+  OMPD_ACCESS(kmp_base_info_t, th_current_task)                                \
+  OMPD_ACCESS(kmp_base_info_t, th_team)                                        \
+  OMPD_ACCESS(kmp_base_info_t, th_info)                                        \
+  OMPD_ACCESS(kmp_base_info_t, ompt_thread_info)                               \
+                                                                               \
+  OMPD_ACCESS(kmp_base_root_t, r_in_parallel)                                  \
+                                                                               \
+  OMPD_ACCESS(kmp_base_team_t, ompt_team_info)                                 \
+  OMPD_ACCESS(kmp_base_team_t, ompt_serialized_team_info)                      \
+  OMPD_ACCESS(kmp_base_team_t, t_active_level)                                 \
+  OMPD_ACCESS(kmp_base_team_t, t_implicit_task_taskdata)                       \
+  OMPD_ACCESS(kmp_base_team_t, t_master_tid)                                   \
+  OMPD_ACCESS(kmp_base_team_t, t_nproc)                                        \
+  OMPD_ACCESS(kmp_base_team_t, t_level)                                        \
+  OMPD_ACCESS(kmp_base_team_t, t_parent)                                       \
+  OMPD_ACCESS(kmp_base_team_t, t_pkfn)                                         \
+  OMPD_ACCESS(kmp_base_team_t, t_threads)                                      \
+                                                                               \
+  OMPD_ACCESS(kmp_desc_t, ds)                                                  \
+                                                                               \
+  OMPD_ACCESS(kmp_desc_base_t, ds_thread)                                      \
+  OMPD_ACCESS(kmp_desc_base_t, ds_tid)                                         \
+                                                                               \
+  OMPD_ACCESS(kmp_info_t, th)                                                  \
+                                                                               \
+  OMPD_ACCESS(kmp_r_sched_t, r_sched_type)                                     \
+  OMPD_ACCESS(kmp_r_sched_t, chunk)                                            \
+                                                                               \
+  OMPD_ACCESS(kmp_root_t, r)                                                   \
+                                                                               \
+  OMPD_ACCESS(kmp_internal_control_t, dynamic)                                 \
+  OMPD_ACCESS(kmp_internal_control_t, max_active_levels)                       \
+  OMPD_ACCESS(kmp_internal_control_t, nproc)                                   \
+  OMPD_ACCESS(kmp_internal_control_t, proc_bind)                               \
+  OMPD_ACCESS(kmp_internal_control_t, sched)                                   \
+  OMPD_ACCESS(kmp_internal_control_t, default_device)                          \
+  OMPD_ACCESS(kmp_internal_control_t, thread_limit)                            \
+                                                                               \
+  OMPD_ACCESS(kmp_taskdata_t, ompt_task_info)                                  \
+  OMPD_ACCESS(kmp_taskdata_t, td_flags)                                        \
+  OMPD_ACCESS(kmp_taskdata_t, td_icvs)                                         \
+  OMPD_ACCESS(kmp_taskdata_t, td_parent)                                       \
+  OMPD_ACCESS(kmp_taskdata_t, td_team)                                         \
+                                                                               \
+  OMPD_ACCESS(kmp_task_t, routine)                                             \
+                                                                               \
+  OMPD_ACCESS(kmp_team_p, t)                                                   \
+                                                                               \
+  OMPD_ACCESS(kmp_nested_nthreads_t, used)                                     \
+  OMPD_ACCESS(kmp_nested_nthreads_t, nth)                                      \
+                                                                               \
+  OMPD_ACCESS(kmp_nested_proc_bind_t, used)                                    \
+  OMPD_ACCESS(kmp_nested_proc_bind_t, bind_types)                              \
+                                                                               \
+  OMPD_ACCESS(ompt_task_info_t, frame)                                         \
+  OMPD_ACCESS(ompt_task_info_t, scheduling_parent)                             \
+  OMPD_ACCESS(ompt_task_info_t, task_data)                                     \
+                                                                               \
+  OMPD_ACCESS(ompt_team_info_t, parallel_data)                                 \
+                                                                               \
+  OMPD_ACCESS(ompt_thread_info_t, state)                                       \
+  OMPD_ACCESS(ompt_thread_info_t, wait_id)                                     \
+  OMPD_ACCESS(ompt_thread_info_t, thread_data)                                 \
+                                                                               \
+  OMPD_ACCESS(ompt_data_t, value)                                              \
+  OMPD_ACCESS(ompt_data_t, ptr)                                                \
+                                                                               \
+  OMPD_ACCESS(ompt_frame_t, exit_frame)                                        \
+  OMPD_ACCESS(ompt_frame_t, enter_frame)                                       \
+                                                                               \
+  OMPD_ACCESS(ompt_lw_taskteam_t, parent)                                      \
+  OMPD_ACCESS(ompt_lw_taskteam_t, ompt_team_info)                              \
+  OMPD_ACCESS(ompt_lw_taskteam_t, ompt_task_info)
+
+#define OMPD_FOREACH_BITFIELD(OMPD_BITFIELD)                                   \
+  OMPD_BITFIELD(kmp_tasking_flags_t, final)                                    \
+  OMPD_BITFIELD(kmp_tasking_flags_t, tiedness)                                 \
+  OMPD_BITFIELD(kmp_tasking_flags_t, tasktype)                                 \
+  OMPD_BITFIELD(kmp_tasking_flags_t, task_serial)                              \
+  OMPD_BITFIELD(kmp_tasking_flags_t, tasking_ser)                              \
+  OMPD_BITFIELD(kmp_tasking_flags_t, team_serial)                              \
+  OMPD_BITFIELD(kmp_tasking_flags_t, started)                                  \
+  OMPD_BITFIELD(kmp_tasking_flags_t, executing)                                \
+  OMPD_BITFIELD(kmp_tasking_flags_t, complete)                                 \
+  OMPD_BITFIELD(kmp_tasking_flags_t, freed)                                    \
+  OMPD_BITFIELD(kmp_tasking_flags_t, native)
+
+#define OMPD_FOREACH_SIZEOF(OMPD_SIZEOF)                                       \
+  OMPD_SIZEOF(kmp_info_t)                                                      \
+  OMPD_SIZEOF(kmp_taskdata_t)                                                  \
+  OMPD_SIZEOF(kmp_task_t)                                                      \
+  OMPD_SIZEOF(kmp_tasking_flags_t)                                             \
+  OMPD_SIZEOF(kmp_thread_t)                                                    \
+  OMPD_SIZEOF(ompt_data_t)                                                     \
+  OMPD_SIZEOF(ompt_id_t)                                                       \
+  OMPD_SIZEOF(__kmp_avail_proc)                                                \
+  OMPD_SIZEOF(__kmp_max_nth)                                                   \
+  OMPD_SIZEOF(__kmp_stksize)                                                   \
+  OMPD_SIZEOF(__kmp_omp_cancellation)                                          \
+  OMPD_SIZEOF(__kmp_max_task_priority)                                         \
+  OMPD_SIZEOF(__kmp_display_affinity)                                          \
+  OMPD_SIZEOF(__kmp_affinity_format)                                           \
+  OMPD_SIZEOF(__kmp_tool_libraries)                                            \
+  OMPD_SIZEOF(__kmp_tool_verbose_init)                                         \
+  OMPD_SIZEOF(__kmp_tool)                                                      \
+  OMPD_SIZEOF(ompd_state)                                                      \
+  OMPD_SIZEOF(kmp_nested_nthreads_t)                                           \
+  OMPD_SIZEOF(__kmp_nested_nth)                                                \
+  OMPD_SIZEOF(kmp_nested_proc_bind_t)                                          \
+  OMPD_SIZEOF(__kmp_nested_proc_bind)                                          \
+  OMPD_SIZEOF(int)                                                             \
+  OMPD_SIZEOF(char)                                                            \
+  OMPD_SIZEOF(__kmp_gtid)                                                      \
+  OMPD_SIZEOF(__kmp_nth)
+
+#endif /* OMPD_SUPPORT */
+#endif

openmp/runtime/src/ompd-specific.cpp

+/*
+ * ompd-specific.cpp -- OpenMP debug support
+ */
+
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ompd-specific.h"
+
+#if OMPD_SUPPORT
+
+/**
+ * Declaration of symbols to hold struct size and member offset information
+ */
+
+#define ompd_declare_access(t, m) uint64_t ompd_access__##t##__##m;
+OMPD_FOREACH_ACCESS(ompd_declare_access)
+#undef ompd_declare_access
+
+#define ompd_declare_sizeof_member(t, m) uint64_t ompd_sizeof__##t##__##m;
+OMPD_FOREACH_ACCESS(ompd_declare_sizeof_member)
+#undef ompd_declare_sizeof_member
+
+#define ompd_declare_bitfield(t, m) uint64_t ompd_bitfield__##t##__##m;
+OMPD_FOREACH_BITFIELD(ompd_declare_bitfield)
+#undef ompd_declare_bitfield
+
+#define ompd_declare_sizeof(t) uint64_t ompd_sizeof__##t;
+OMPD_FOREACH_SIZEOF(ompd_declare_sizeof)
+#undef ompd_declare_sizeof
+
+volatile const char **ompd_dll_locations = NULL;
+uint64_t ompd_state = 0;
+
+char *ompd_env_block = NULL;
+ompd_size_t ompd_env_block_size = 0;
+
+void ompd_init() {
+
+  static int ompd_initialized = 0;
+
+  if (ompd_initialized)
+    return;
+
+    /**
+     * Calculate member offsets for structs and unions
+     */
+
+#define ompd_init_access(t, m)                                                 \
+  ompd_access__##t##__##m = (uint64_t) & (((t *)0)->m);
+  OMPD_FOREACH_ACCESS(ompd_init_access)
+#undef ompd_init_access
+
+  /**
+   * Create bit mask for bitfield access
+   */
+
+#define ompd_init_bitfield(t, m)                                               \
+  ompd_bitfield__##t##__##m = 0;                                               \
+  ((t *)(&ompd_bitfield__##t##__##m))->m = 1;
+  OMPD_FOREACH_BITFIELD(ompd_init_bitfield)
+#undef ompd_init_bitfield
+
+  /**
+   * Calculate type size information
+   */
+
+#define ompd_init_sizeof_member(t, m)                                          \
+  ompd_sizeof__##t##__##m = sizeof(((t *)0)->m);
+  OMPD_FOREACH_ACCESS(ompd_init_sizeof_member)
+#undef ompd_init_sizeof_member
+
+#define ompd_init_sizeof(t) ompd_sizeof__##t = sizeof(t);
+  OMPD_FOREACH_SIZEOF(ompd_init_sizeof)
+#undef ompd_init_sizeof
+
+  char *libname = NULL;
+
+#if KMP_OS_UNIX
+  // Find the location of libomp.so thru dladdr and replace the libomp with
+  // libompd to get the full path of libompd
+  Dl_info dl_info;
+  int ret = dladdr((void *)ompd_init, &dl_info);
+  if (!ret) {
+    fprintf(stderr, "%s\n", dlerror());
+  }
+  int lib_path_length;
+  if (strrchr(dl_info.dli_fname, '/')) {
+    lib_path_length = strrchr(dl_info.dli_fname, '/') - dl_info.dli_fname;
+
+    libname =
+        (char *)malloc(lib_path_length + 12 /*for '/libompd.so' and '\0'*/);
+    strcpy(libname, dl_info.dli_fname);
+    memcpy(strrchr(libname, '/'), "/libompd.so\0", 12);
+  }
+#endif
+
+  const char *ompd_env_var = getenv("OMP_DEBUG");
+  if (ompd_env_var && !strcmp(ompd_env_var, "enabled")) {
+    fprintf(stderr, "OMP_OMPD active\n");
+    ompt_enabled.enabled = 1;
+    ompd_state |= OMPD_ENABLE_BP;
+  }
+
+  ompd_initialized = 1;
+  ompd_dll_locations = (volatile const char **)malloc(3 * sizeof(const char *));
+  ompd_dll_locations[0] = "libompd.so";
+  ompd_dll_locations[1] = libname;
+  ompd_dll_locations[2] = NULL;
+  ompd_dll_locations_valid();
+}
+
+void __attribute__((noinline)) ompd_dll_locations_valid(void) {
+  /* naive way of implementing hard to opt-out empty function
+     we might want to use a separate object file? */
+  asm("");
+}
+
+void ompd_bp_parallel_begin(void) {
+  /* naive way of implementing hard to opt-out empty function
+     we might want to use a separate object file? */
+  asm("");
+}
+void ompd_bp_parallel_end(void) {
+  /* naive way of implementing hard to opt-out empty function
+     we might want to use a separate object file? */
+  asm("");
+}
+void ompd_bp_task_begin(void) {
+  /* naive way of implementing hard to opt-out empty function
+     we might want to use a separate object file? */
+  asm("");
+}
+void ompd_bp_task_end(void) {
+  /* naive way of implementing hard to opt-out empty function
+     we might want to use a separate object file? */
+  asm("");
+}
+void ompd_bp_thread_begin(void) {
+  /* naive way of implementing hard to opt-out empty function
+     we might want to use a separate object file? */
+  asm("");
+}
+void ompd_bp_thread_end(void) {
+  /* naive way of implementing hard to opt-out empty function
+     we might want to use a separate object file? */
+  asm("");
+}
+
+#endif /* OMPD_SUPPORT */

openmp/runtime/src/ompt-general.cpp

if (ompt_enabled.ompt_callback_implicit_task) {
           ompt_scope_begin, parallel_data, task_data, 1, 1, ompt_task_initial);
     }
 
     ompt_set_thread_state(root_thread, ompt_state_work_serial);
   }
 }
 
 void ompt_fini() {
-  if (ompt_enabled.enabled) {
+  if (ompt_enabled.enabled
+#if OMPD_SUPPORT
+      && ompt_start_tool_result && ompt_start_tool_result->finalize
+#endif
+  ) {
     ompt_start_tool_result->finalize(&(ompt_start_tool_result->tool_data));
   }
 
   if (ompt_tool_module)
     OMPT_DLCLOSE(ompt_tool_module);
   memset(&ompt_enabled, 0, sizeof(ompt_enabled));
 }
 

openmp/runtime/src/ompt-specific.cpp

if (always ||
     link_lwt->ompt_task_info = *OMPT_CUR_TASK_INFO(thr);
     *OMPT_CUR_TASK_INFO(thr) = tmp_task;
 
     // link the taskteam into the list of taskteams:
     ompt_lw_taskteam_t *my_parent =
         thr->th.th_team->t.ompt_serialized_team_info;
     link_lwt->parent = my_parent;
     thr->th.th_team->t.ompt_serialized_team_info = link_lwt;
+#if OMPD_SUPPORT
+    if (ompd_state & OMPD_ENABLE_BP) {
+      ompd_bp_parallel_begin();
+    }
+#endif
   } else {
     // this is the first serialized team, so we just store the values in the
     // team and drop the taskteam-object
     *OMPT_CUR_TEAM_INFO(thr) = lwt->ompt_team_info;
+#if OMPD_SUPPORT
+    if (ompd_state & OMPD_ENABLE_BP) {
+      ompd_bp_parallel_begin();
+    }
+#endif
     *OMPT_CUR_TASK_INFO(thr) = lwt->ompt_task_info;
   }
 }
 
 void __ompt_lw_taskteam_unlink(kmp_info_t *thr) {
   ompt_lw_taskteam_t *lwtask = thr->th.th_team->t.ompt_serialized_team_info;
   if (lwtask) {
+#if OMPD_SUPPORT
+    if (ompd_state & OMPD_ENABLE_BP) {
+      ompd_bp_parallel_end();
+    }
+#endif
     thr->th.th_team->t.ompt_serialized_team_info = lwtask->parent;
 
     ompt_team_info_t tmp_team = lwtask->ompt_team_info;
     lwtask->ompt_team_info = *OMPT_CUR_TEAM_INFO(thr);
     *OMPT_CUR_TEAM_INFO(thr) = tmp_team;
 
     ompt_task_info_t tmp_task = lwtask->ompt_task_info;
     lwtask->ompt_task_info = *OMPT_CUR_TASK_INFO(thr);