[OpenMP][OMPT] Implement missing event callbacks in ompt-multiplex.h

[protze.joachim]

Summary

According to the OpenMP standard (5.1) five target related events are
missing in the implementation. This patch adds these five callbacks.

Patch prepared by Semih Burak

openmp/tools/multiplex/ompt-multiplex.h

#define OMPT_LOAD_CLIENT_FOREACH_OMPT_EVENT(macro)                             \
   macro(callback_lock_init, ompt_callback_mutex_acquire_t, 24);                \
   macro(callback_lock_destroy, ompt_callback_mutex_t, 25);                     \
   macro(callback_mutex_acquire, ompt_callback_mutex_acquire_t, 26);            \
   macro(callback_mutex_acquired, ompt_callback_mutex_t, 27);                   \
   macro(callback_nest_lock, ompt_callback_nest_lock_t, 28);                    \
   macro(callback_flush, ompt_callback_flush_t, 29);                            \
   macro(callback_cancel, ompt_callback_cancel_t, 30);                          \
   macro(callback_reduction, ompt_callback_sync_region_t, 31);                  \
-  macro(callback_dispatch, ompt_callback_dispatch_t, 32);
+  macro(callback_dispatch, ompt_callback_dispatch_t, 32);                      \
+  macro(callback_target_emi, ompt_callback_target_emi_t, 33);                  \
+  macro(callback_target_data_op_emi, ompt_callback_target_data_op_emi_t, 34);  \
+  macro(callback_target_submit_emi, ompt_callback_target_submit_emi_t, 35);    \
+  macro(callback_target_map_emi, ompt_callback_target_map_emi_t, 36);          \
+  macro(callback_error, ompt_callback_error_t, 37);
+
 
 typedef struct ompt_multiplex_callbacks_s {
 #define ompt_event_macro(event, callback, eventid) callback ompt_##event
 
   OMPT_LOAD_CLIENT_FOREACH_OMPT_EVENT(ompt_event_macro)
 
 #undef ompt_event_macro
 } ompt_multiplex_callbacks_t;
 

 static ompt_data_t *ompt_multiplex_get_own_task_data(ompt_data_t *data) {
 #ifndef OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TASK_DATA
   return ompt_multiplex_get_own_ompt_data(data);
 #else
   return data;
 #endif
 }
 
-
 static ompt_data_t *ompt_multiplex_get_own_target_data(ompt_data_t *data) {
 #ifndef OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TARGET_DATA
   return ompt_multiplex_get_own_ompt_data(data);
 #else
   return data;
 #endif
 }
 
-
-
 static ompt_data_t *ompt_multiplex_get_client_thread_data(ompt_data_t *data) {
 #ifndef OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_THREAD_DATA
   return ompt_multiplex_get_client_ompt_data(data);
 #else
   return OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_THREAD_DATA(data);
 #endif
 }
 
 static ompt_data_t *ompt_multiplex_get_client_parallel_data(ompt_data_t *data) {
 #ifndef OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_PARALLEL_DATA
   return ompt_multiplex_get_client_ompt_data(data);
 #else
   return OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_PARALLEL_DATA(data);
 #endif
 }
 
 static ompt_data_t *ompt_multiplex_get_client_task_data(ompt_data_t *data) {
 #ifndef OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TASK_DATA
   return ompt_multiplex_get_client_ompt_data(data);
 #else
   return OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TASK_DATA(data);
 #endif
 }
 
-
 static ompt_data_t *ompt_multiplex_get_client_target_data(ompt_data_t *data) {
 #ifndef OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TARGET_DATA
   return ompt_multiplex_get_own_ompt_data(data);
 #else
   return OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TARGET_DATA(data);
 #endif
 }
 
static void ompt_multiplex_callback_dispatch(ompt_data_t *parallel_data,
   }
   if (ompt_multiplex_client_callbacks.ompt_callback_dispatch) {
     ompt_multiplex_client_callbacks.ompt_callback_dispatch(
         ompt_multiplex_get_client_parallel_data(parallel_data),
         ompt_multiplex_get_client_task_data(task_data), kind, instance);
   }
 }
 
+
+static void ompt_multiplex_callback_target_emi(
+    ompt_target_t kind, ompt_scope_endpoint_t endpoint, int device_num,
+    ompt_data_t *task_data, ompt_data_t *target_task_data,
+    ompt_data_t *target_data, const void *codeptr_ra) {
+  if (endpoint == ompt_scope_begin) {
+#ifndef OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TARGET_DATA
+    ompt_multiplex_allocate_data_pair(target_data);
+#endif
+#ifndef OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TASK_DATA
+    if (target_task_data->ptr == NULL)
+      ompt_multiplex_allocate_data_pair(target_task_data);
+#endif
+    if (ompt_multiplex_own_callbacks.ompt_callback_target_emi) {
+      ompt_multiplex_own_callbacks.ompt_callback_target_emi(
+          kind, endpoint, device_num,
+          ompt_multiplex_get_own_task_data(task_data),
+          ompt_multiplex_get_own_task_data(target_task_data),
+          ompt_multiplex_get_own_target_data(target_data), codeptr_ra);
+    }
+    if (ompt_multiplex_client_callbacks.ompt_callback_target_emi) {
+      ompt_multiplex_client_callbacks.ompt_callback_target_emi(
+          kind, endpoint, device_num,
+          ompt_multiplex_get_client_task_data(task_data),
+          ompt_multiplex_get_client_task_data(target_task_data),
+          ompt_multiplex_get_client_target_data(target_data), codeptr_ra);
+    }
+  } else {
+// defines to make sure, callbacks are called in correct order depending on
+// defines set by the user
+#if defined(OMPT_MULTIPLEX_CUSTOM_DELETE_TARGET_DATA) ||                       \
+    !defined(OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TARGET_DATA)
+    if (ompt_multiplex_own_callbacks.ompt_callback_target_emi) {
+      ompt_multiplex_own_callbacks.ompt_callback_target_emi(
+          kind, endpoint, device_num,
+          ompt_multiplex_get_own_task_data(task_data),
+          ompt_multiplex_get_own_task_data(target_task_data),
+          ompt_multiplex_get_own_target_data(target_data), codeptr_ra);
+    }
+#endif
+
+    if (ompt_multiplex_client_callbacks.ompt_callback_target_emi) {
+      ompt_multiplex_client_callbacks.ompt_callback_target_emi(
+          kind, endpoint, device_num,
+          ompt_multiplex_get_client_task_data(task_data),
+          ompt_multiplex_get_client_task_data(target_task_data),
+          ompt_multiplex_get_client_target_data(target_data), codeptr_ra);
+    }
+
+#if defined(OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TARGET_DATA) &&                   \
+    !defined(OMPT_MULTIPLEX_CUSTOM_DELETE_TARGET_DATA)
+    if (ompt_multiplex_own_callbacks.ompt_callback_target_emi) {
+      ompt_multiplex_own_callbacks.ompt_callback_target_emi(
+          kind, endpoint, device_num,
+          ompt_multiplex_get_own_task_data(task_data),
+          ompt_multiplex_get_own_task_data(target_task_data),
+          ompt_multiplex_get_own_target_data(target_data), codeptr_ra);
+    }
+#endif
+
+#ifndef OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TARGET_DATA
+    ompt_multiplex_free_data_pair(target_data);
+#endif
+
+#ifndef OMPT_MULTIPLEX_CUSTOM_GET_CLIENT_TASK_DATA
+    ompt_multiplex_free_data_pair(target_task_data);
+#endif
+
+#if defined(OMPT_MULTIPLEX_CUSTOM_DELETE_TARGET_DATA)
+    OMPT_MULTIPLEX_CUSTOM_DELETE_TARGET_DATA(target_data);
+#endif
+
+#if defined(OMPT_MULTIPLEX_CUSTOM_DELETE_TASK_DATA)
+    OMPT_MULTIPLEX_CUSTOM_DELETE_TASK_DATA(target_task_data);
+#endif
+  }
+}
+
+static void ompt_multiplex_callback_target_data_op_emi(
+    ompt_scope_endpoint_t endpoint, ompt_data_t *target_task_data,
+    ompt_data_t *target_data, ompt_id_t *host_op_id,
+    ompt_target_data_op_t optype, void *src_addr, int src_device_num,
+    void *dest_addr, int dest_device_num, size_t bytes,
+    const void *codeptr_ra) {
+  if (ompt_multiplex_own_callbacks.ompt_callback_target_data_op_emi) {
+    ompt_multiplex_own_callbacks.ompt_callback_target_data_op_emi(
+        endpoint, ompt_multiplex_get_own_task_data(target_task_data),
+        ompt_multiplex_get_own_target_data(target_data), host_op_id, optype,
+        src_addr, src_device_num, dest_addr, bytes, dest_device_num,
+        codeptr_ra);
+  }
+  if (ompt_multiplex_client_callbacks.ompt_callback_target_data_op_emi) {
+    ompt_multiplex_client_callbacks.ompt_callback_target_data_op_emi(
+        endpoint, ompt_multiplex_get_client_task_data(target_task_data),
+        ompt_multiplex_get_client_target_data(target_data), host_op_id, optype,
+        src_addr, src_device_num, dest_addr, bytes, dest_device_num,
+        codeptr_ra);
+  }
+}
+
+static void ompt_multiplex_callback_target_submit_emi(
+    ompt_scope_endpoint_t endpoint, ompt_data_t *target_data,
+    ompt_id_t *host_op_id, unsigned int requested_num_teams) {
+  if (ompt_multiplex_own_callbacks.ompt_callback_target_submit_emi) {
+    ompt_multiplex_own_callbacks.ompt_callback_target_submit_emi(
+        endpoint, ompt_multiplex_get_own_target_data(target_data), host_op_id,
+        requested_num_teams);
+  }
+  if (ompt_multiplex_client_callbacks.ompt_callback_target_submit_emi) {
+    ompt_multiplex_client_callbacks.ompt_callback_target_submit_emi(
+        endpoint, ompt_multiplex_get_client_target_data(target_data),
+        host_op_id, requested_num_teams);
+  }
+}
+
+static void ompt_multiplex_callback_target_map_emi(
+    ompt_data_t *target_data, unsigned int nitems, void **host_addr,
+    void **device_addr, size_t *bytes, unsigned int *mapping_flags,
+    const void *codeptr_ra) {
+  if (ompt_multiplex_own_callbacks.ompt_callback_target_map_emi) {
+    ompt_multiplex_own_callbacks.ompt_callback_target_map_emi(
+        ompt_multiplex_get_own_target_data(target_data), nitems, host_addr,
+        device_addr, bytes, mapping_flags, codeptr_ra);
+  }
+  if (ompt_multiplex_client_callbacks.ompt_callback_target_map_emi) {
+    ompt_multiplex_client_callbacks.ompt_callback_target_map_emi(
+        ompt_multiplex_get_client_target_data(target_data), nitems, host_addr,
+        device_addr, bytes, mapping_flags, codeptr_ra);
+  }
+}
+
+static void ompt_multiplex_callback_error(ompt_severity_t severity,
+                                          const char *message, size_t length,
+                                          const void *codeptr_ra) {
+  if (ompt_multiplex_own_callbacks.ompt_callback_error) {
+    ompt_multiplex_own_callbacks.ompt_callback_error(severity, message, length,
+                                                     codeptr_ra);
+  }
+  if (ompt_multiplex_client_callbacks.ompt_callback_error) {
+    ompt_multiplex_client_callbacks.ompt_callback_error(severity, message,
+                                                        length, codeptr_ra);
+  }
+}
+
+
 // runtime entry functions
 
 int ompt_multiplex_own_get_task_info(int ancestor_level, int *type,
                                      ompt_data_t **task_data,
                                      ompt_frame_t **task_frame,
                                      ompt_data_t **parallel_data,
                                      int *thread_num) {
   int ret = ompt_multiplex_get_task_info(ancestor_level, type, task_data,