[OMPT] Rename ompt_frame_t to omp_frame_t

[sconvent]

Summary

Rename ompt_frame_t to omp_frame_t, as defined in the spec.

[omalyshe]

Do we really need this change?
I found a comment from John M-C at https://github.com/OpenMPToolsInterface/OpenMP-4.5-spec/commit/7bed0e0e6b96e0cfa6d964de2101c2172a0a47e7#commitcomment-24561958 (that commit replaced ompt_frame_t to omp_frame_t in the Spec):

This change needs to be reverted. We had originally planned to use omp_frame_t, but now are using ompt_frame_t because it turns out that we can't share the type: OMPD needs ompd_address_t instead of void * for the addresses.

runtime/src/include/50/ompt.h.var

302 ↗

(On Diff #135233)

Add space before /*

344 ↗

(On Diff #135233)

Add space before /*

[sconvent]

Fix indentation

[protze.joachim]

As far as I know, the current implementation is very close to the specification in TR6.
Here we have a tiny diff between the spec and the implementation. I agree that we should not apply this patch if we will roll back the change in the spec.

So I propose to discuss this in the Tools WG first and then decide whether to apply the patch. I will schedule this for the next call.

[protze.joachim]

Result of discussion in Tools WG was that the spec will keep omp_frame_t. I will submit this patch together with D43568

[Hahnfeld]

Ok, let's do this.

openmp/trunk/runtime/src/include/50/ompt.h.var

 static const ompt_data_t ompt_data_none = {0};
 
 typedef uint64_t ompt_wait_id_t;
 static const ompt_wait_id_t ompt_wait_id_none = 0;
 
 typedef void ompt_device_t;
 
 /*---------------------
- * ompt_frame_t
+ * omp_frame_t
  *---------------------*/
 
-typedef struct ompt_frame_t {
+typedef struct omp_frame_t {
     void *exit_frame;    /* next frame is user code     */
     void *enter_frame;   /* previous frame is user code */
-} ompt_frame_t;
+} omp_frame_t;
 
 
 /*---------------------
  * dependences types
  *---------------------*/
 
 typedef enum ompt_task_dependence_flag_t {
     // a two bit field for the dependence type
typedef void (*ompt_callback_implicit_task_t) (
     ompt_data_t *parallel_data,           /* data of parallel region             */
     ompt_data_t *task_data,               /* data of implicit task               */
     unsigned int team_size,               /* team size                           */
     unsigned int thread_num               /* thread number of calling thread     */
 );
 
 typedef void (*ompt_callback_parallel_begin_t) (
     ompt_data_t *encountering_task_data,         /* data of encountering task           */
-    const ompt_frame_t *encountering_task_frame, /* frame data of encountering task     */
+    const omp_frame_t *encountering_task_frame,  /* frame data of encountering task     */
     ompt_data_t *parallel_data,                  /* data of parallel region             */
     unsigned int requested_team_size,            /* requested number of threads in team */
     ompt_invoker_t invoker,                      /* invoker of master task              */
     const void *codeptr_ra                       /* return address of runtime call      */
 );
 
 typedef void (*ompt_callback_parallel_end_t) (
     ompt_data_t *parallel_data,           /* data of parallel region             */

 typedef void (*ompt_callback_task_schedule_t) (
     ompt_data_t *prior_task_data,         /* data of prior task                  */
     ompt_task_status_t prior_task_status, /* status of prior task                */
     ompt_data_t *next_task_data           /* data of next task                   */
 );
 
 typedef void (*ompt_callback_task_create_t) (
     ompt_data_t *encountering_task_data,         /* data of parent task                 */
-    const ompt_frame_t *encountering_task_frame, /* frame data for parent task          */
+    const omp_frame_t *encountering_task_frame,  /* frame data for parent task          */
     ompt_data_t *new_task_data,                  /* data of created task                */
     int type,                                    /* type of created task                */
     int has_dependences,                         /* created task has dependences        */
     const void *codeptr_ra                       /* return address of runtime call      */
 );
 
 /* task dependences */
 typedef void (*ompt_callback_task_dependences_t) (
OMPT_API_FUNCTION(int, ompt_get_parallel_info, (
     int *team_size
 ));
 
 /* task */
 OMPT_API_FUNCTION(int, ompt_get_task_info, (
     int ancestor_level,
     int *type,
     ompt_data_t **task_data,
-    ompt_frame_t **task_frame,
+    omp_frame_t **task_frame,
     ompt_data_t **parallel_data,
     int *thread_num
 ));
 
 /* procs */
 OMPT_API_FUNCTION(int, ompt_get_num_procs, (void));
 
 /* places */

openmp/trunk/runtime/src/kmp_csupport.cpp

 #endif
 
   // maybe to save thr_state is enough here
   {
     va_list ap;
     va_start(ap, microtask);
 
 #if OMPT_SUPPORT
-    ompt_frame_t *ompt_frame;
+    omp_frame_t *ompt_frame;
     if (ompt_enabled.enabled) {
       kmp_info_t *master_th = __kmp_threads[gtid];
       kmp_team_t *parent_team = master_th->th.th_team;
       ompt_lw_taskteam_t *lwt = parent_team->t.ompt_serialized_team_info;
       if (lwt)
         ompt_frame = &(lwt->ompt_task_info.frame);
       else {
         int tid = __kmp_tid_from_gtid(gtid);
if (__kmp_env_consistency_check) {
     if (loc == 0) {
       KMP_WARNING(ConstructIdentInvalid); // ??? What does it mean for the user?
     }
 
     __kmp_check_barrier(global_tid, ct_barrier, loc);
   }
 
 #if OMPT_SUPPORT
-  ompt_frame_t *ompt_frame;
+  omp_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     if (ompt_frame->enter_frame == NULL)
       ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(global_tid);
   }
 #endif
   __kmp_threads[global_tid]->th.th_ident = loc;
kmp_int32 __kmpc_barrier_master(ident_t *loc, kmp_int32 global_tid) {
 
   if (!TCR_4(__kmp_init_parallel))
     __kmp_parallel_initialize();
 
   if (__kmp_env_consistency_check)
     __kmp_check_barrier(global_tid, ct_barrier, loc);
 
 #if OMPT_SUPPORT
-  ompt_frame_t *ompt_frame;
+  omp_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     if (ompt_frame->enter_frame == NULL)
       ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(global_tid);
   }
 #endif
 #if USE_ITT_NOTIFY
kmp_int32 __kmpc_barrier_master_nowait(ident_t *loc, kmp_int32 global_tid) {
   if (__kmp_env_consistency_check) {
     if (loc == 0) {
       KMP_WARNING(ConstructIdentInvalid); // ??? What does it mean for the user?
     }
     __kmp_check_barrier(global_tid, ct_barrier, loc);
   }
 
 #if OMPT_SUPPORT
-  ompt_frame_t *ompt_frame;
+  omp_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     if (ompt_frame->enter_frame == NULL)
       ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(global_tid);
   }
 #endif
 #if USE_ITT_NOTIFY
void __kmpc_copyprivate(ident_t *loc, kmp_int32 gtid, size_t cpy_size,
   }
 
   // ToDo: Optimize the following two barriers into some kind of split barrier
 
   if (didit)
     *data_ptr = cpy_data;
 
 #if OMPT_SUPPORT
-  ompt_frame_t *ompt_frame;
+  omp_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     if (ompt_frame->enter_frame == NULL)
       ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(gtid);
   }
 #endif
 /* This barrier is not a barrier region boundary */

 // this barrier should be invisible to a customer and to the threading profile
 // tool (it's neither a terminating barrier nor customer's code, it's
 // used for an internal purpose)
 #if OMPT_SUPPORT
     // JP: can this barrier potentially leed to task scheduling?
     // JP: as long as there is a barrier in the implementation, OMPT should and
     // will provide the barrier events
     //         so we set-up the necessary frame/return addresses.
-    ompt_frame_t *ompt_frame;
+    omp_frame_t *ompt_frame;
     if (ompt_enabled.enabled) {
       __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
       if (ompt_frame->enter_frame == NULL)
         ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
       OMPT_STORE_RETURN_ADDRESS(global_tid);
     }
 #endif
 #if USE_ITT_NOTIFY
#endif // OMP_40_ENABLED
 
   } else if (TEST_REDUCTION_METHOD(packed_reduction_method,
                                    tree_reduce_block)) {
 
 // case tree_reduce_block:
 // this barrier should be visible to a customer and to the threading profile
 // tool (it's a terminating barrier on constructs if NOWAIT not specified)
 #if OMPT_SUPPORT
-    ompt_frame_t *ompt_frame;
+    omp_frame_t *ompt_frame;
     if (ompt_enabled.enabled) {
       __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
       if (ompt_frame->enter_frame == NULL)
         ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
       OMPT_STORE_RETURN_ADDRESS(global_tid);
     }
 #endif
 #if USE_ITT_NOTIFY
#endif // OMP_40_ENABLED
   // tool (it's a terminating barrier on constructs if NOWAIT not specified)
 
   if (packed_reduction_method == critical_reduce_block) {
 
     __kmp_end_critical_section_reduce_block(loc, global_tid, lck);
 
 // TODO: implicit barrier: should be exposed
 #if OMPT_SUPPORT
-    ompt_frame_t *ompt_frame;
+    omp_frame_t *ompt_frame;
     if (ompt_enabled.enabled) {
       __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
       if (ompt_frame->enter_frame == NULL)
         ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
       OMPT_STORE_RETURN_ADDRESS(global_tid);
     }
 #endif
 #if USE_ITT_NOTIFY
     __kmp_threads[global_tid]->th.th_ident = loc;
 #endif
     __kmp_barrier(bs_plain_barrier, global_tid, FALSE, 0, NULL, NULL);
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     if (ompt_enabled.enabled) {
       ompt_frame->enter_frame = NULL;
     }
 #endif
 
   } else if (packed_reduction_method == empty_reduce_block) {
 
 // usage: if team size==1, no synchronization is required (Intel platforms only)
 
 // TODO: implicit barrier: should be exposed
 #if OMPT_SUPPORT
-    ompt_frame_t *ompt_frame;
+    omp_frame_t *ompt_frame;
     if (ompt_enabled.enabled) {
       __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
       if (ompt_frame->enter_frame == NULL)
         ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
       OMPT_STORE_RETURN_ADDRESS(global_tid);
     }
 #endif
 #if USE_ITT_NOTIFY
     __kmp_threads[global_tid]->th.th_ident = loc;
 #endif
     __kmp_barrier(bs_plain_barrier, global_tid, FALSE, 0, NULL, NULL);
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     if (ompt_enabled.enabled) {
       ompt_frame->enter_frame = NULL;
     }
 #endif
 
   } else if (packed_reduction_method == atomic_reduce_block) {
 
 #if OMPT_SUPPORT
-    ompt_frame_t *ompt_frame;
+    omp_frame_t *ompt_frame;
     if (ompt_enabled.enabled) {
       __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
       if (ompt_frame->enter_frame == NULL)
         ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
       OMPT_STORE_RETURN_ADDRESS(global_tid);
     }
 #endif
 // TODO: implicit barrier: should be exposed

openmp/trunk/runtime/src/kmp_gsupport.cpp

 
 #include "kmp_ftn_os.h"
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_BARRIER)(void) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_barrier");
   KA_TRACE(20, ("GOMP_barrier: T#%d\n", gtid));
 #if OMPT_SUPPORT && OMPT_OPTIONAL
-  ompt_frame_t *ompt_frame;
+  omp_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(gtid);
   }
 #endif
   __kmpc_barrier(&loc, gtid);
 #if OMPT_SUPPORT && OMPT_OPTIONAL
void *KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SINGLE_COPY_START)(void) {
   // copyprivate data pointer as an argument.
   if (__kmp_enter_single(gtid, &loc, FALSE))
     return NULL;
 
 // Wait for the first thread to set the copyprivate data pointer,
 // and for all other threads to reach this point.
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
-  ompt_frame_t *ompt_frame;
+  omp_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(gtid);
   }
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 
void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SINGLE_COPY_END)(void *data) {
   KA_TRACE(20, ("GOMP_single_copy_end: T#%d\n", gtid));
 
   // Set the copyprivate data pointer fo the team, then hit the barrier so that
   // the other threads will continue on and read it.  Hit another barrier before
   // continuing, so that the know that the copyprivate data pointer has been
   // propagated to all threads before trying to reuse the t_copypriv_data field.
   __kmp_team_from_gtid(gtid)->t.t_copypriv_data = data;
 #if OMPT_SUPPORT && OMPT_OPTIONAL
-  ompt_frame_t *ompt_frame;
+  omp_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(gtid);
   }
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 #if OMPT_SUPPORT && OMPT_OPTIONAL

 #ifndef KMP_DEBUG
 static
 #endif /* KMP_DEBUG */
     void
     __kmp_GOMP_microtask_wrapper(int *gtid, int *npr, void (*task)(void *),
                                  void *data) {
 #if OMPT_SUPPORT
   kmp_info_t *thr;
-  ompt_frame_t *ompt_frame;
+  omp_frame_t *ompt_frame;
   omp_state_t enclosing_state;
 
   if (ompt_enabled.enabled) {
     // get pointer to thread data structure
     thr = __kmp_threads[*gtid];
 
     // save enclosing task state; set current state for task
     enclosing_state = thr->th.ompt_thread_info.state;
__kmp_GOMP_parallel_microtask_wrapper(int *gtid, int *npr,
                                           long chunk_size) {
   // Intialize the loop worksharing construct.
 
   KMP_DISPATCH_INIT(loc, *gtid, schedule, start, end, incr, chunk_size,
                     schedule != kmp_sch_static);
 
 #if OMPT_SUPPORT
   kmp_info_t *thr;
-  ompt_frame_t *ompt_frame;
+  omp_frame_t *ompt_frame;
   omp_state_t enclosing_state;
 
   if (ompt_enabled.enabled) {
     thr = __kmp_threads[*gtid];
     // save enclosing task state; set current state for task
     enclosing_state = thr->th.ompt_thread_info.state;
     thr->th.ompt_thread_info.state = omp_state_work_parallel;
 

 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_START)(void (*task)(void *),
                                                        void *data,
                                                        unsigned num_threads) {
   int gtid = __kmp_entry_gtid();
 
 #if OMPT_SUPPORT
-  ompt_frame_t *parent_frame, *frame;
+  omp_frame_t *parent_frame, *frame;
 
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &parent_frame, NULL, NULL);
     parent_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(gtid);
   }
 #endif
 

 LOOP_NEXT(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_NEXT),
           { KMP_DISPATCH_FINI_CHUNK(&loc, gtid); })
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_END)(void) {
   int gtid = __kmp_get_gtid();
   KA_TRACE(20, ("GOMP_loop_end: T#%d\n", gtid))
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
-  ompt_frame_t *ompt_frame;
+  omp_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(gtid);
   }
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 #if OMPT_SUPPORT && OMPT_OPTIONAL
void func(void (*task)(void *), void *data, unsigned num_threads, long lb,   \
     ompt_post();                                                               \
                                                                                \
     KA_TRACE(20, (#func " exit: T#%d\n", gtid));                               \
   }
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
 
 #define OMPT_LOOP_PRE()                                                        \
-  ompt_frame_t *parent_frame;                                                  \
+  omp_frame_t *parent_frame;                                                   \
   if (ompt_enabled.enabled) {                                                  \
     __ompt_get_task_info_internal(0, NULL, NULL, &parent_frame, NULL, NULL);   \
     parent_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);                     \
     OMPT_STORE_RETURN_ADDRESS(gtid);                                           \
   }
 
 #define OMPT_LOOP_POST()                                                       \
   if (ompt_enabled.enabled) {                                                  \
#endif
   return (unsigned)lb;
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START)(
     void (*task)(void *), void *data, unsigned num_threads, unsigned count) {
   int gtid = __kmp_entry_gtid();
 
 #if OMPT_SUPPORT
-  ompt_frame_t *parent_frame;
+  omp_frame_t *parent_frame;
 
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &parent_frame, NULL, NULL);
     parent_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(gtid);
   }
 #endif
 
#endif
   KA_TRACE(20, ("GOMP_parallel_sections_start exit: T#%d\n", gtid));
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SECTIONS_END)(void) {
   int gtid = __kmp_get_gtid();
   KA_TRACE(20, ("GOMP_sections_end: T#%d\n", gtid))
 
 #if OMPT_SUPPORT
-  ompt_frame_t *ompt_frame;
+  omp_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(gtid);
   }
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 #if OMPT_SUPPORT

openmp/trunk/runtime/src/kmp_runtime.cpp

#endif
     root = master_th->th.th_root;
     master_active = root->r.r_active;
     master_set_numthreads = master_th->th.th_set_nproc;
 
 #if OMPT_SUPPORT
     ompt_data_t ompt_parallel_data;
     ompt_parallel_data.ptr = NULL;
     ompt_data_t *parent_task_data;
-    ompt_frame_t *ompt_frame;
+    omp_frame_t *ompt_frame;
     ompt_data_t *implicit_task_data;
     void *return_address = NULL;
 
     if (ompt_enabled.enabled) {
       __ompt_get_task_info_internal(0, NULL, &parent_task_data, &ompt_frame,
                                     NULL, NULL);
       return_address = OMPT_LOAD_RETURN_ADDRESS(gtid);
     }

openmp/trunk/runtime/src/kmp_tasking.cpp

static void __kmpc_omp_task_complete_if0_template(ident_t *loc_ref,
   __kmp_task_finish(gtid, task, NULL);
 
   KA_TRACE(10, ("__kmpc_omp_task_complete_if0(exit): T#%d loc=%p task=%p\n",
                 gtid, loc_ref, KMP_TASK_TO_TASKDATA(task)));
 
 #if OMPT_SUPPORT
   if (ompt) {
     __ompt_task_finish(task, NULL);
-    ompt_frame_t *ompt_frame;
+    omp_frame_t *ompt_frame;
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     ompt_frame->enter_frame = NULL;
   }
 #endif
 
   return;
 }
 

openmp/trunk/runtime/src/ompt-general.cpp

  ****************************************************************************/
 
 OMPT_API_ROUTINE ompt_data_t *ompt_get_thread_data(void) {
   return __ompt_get_thread_data_internal();
 }
 
 OMPT_API_ROUTINE int ompt_get_task_info(int ancestor_level, int *type,
                                         ompt_data_t **task_data,
-                                        ompt_frame_t **task_frame,
+                                        omp_frame_t **task_frame,
                                         ompt_data_t **parallel_data,
                                         int *thread_num) {
   return __ompt_get_task_info_internal(ancestor_level, type, task_data,
                                        task_frame, parallel_data, thread_num);
 }
 
 /*****************************************************************************
  * num_procs

openmp/trunk/runtime/src/ompt-internal.h

#define TASK_TYPE_DETAILS_FORMAT(info)                                         \
   ((info->td_flags.task_serial || info->td_flags.tasking_ser)                  \
        ? ompt_task_undeferred                                                  \
        : 0x0) |                                                                \
       ((!(info->td_flags.tiedness)) ? ompt_task_untied : 0x0) |                \
       (info->td_flags.final ? ompt_task_final : 0x0) |                         \
       (info->td_flags.merged_if0 ? ompt_task_mergeable : 0x0)
 
 typedef struct {
-  ompt_frame_t frame;
+  omp_frame_t frame;
   ompt_data_t task_data;
   struct kmp_taskdata *scheduling_parent;
   int thread_num;
 #if OMP_40_ENABLED
   int ndeps;
   ompt_task_dependence_t *deps;
 #endif /* OMP_40_ENABLED */
 } ompt_task_info_t;

openmp/trunk/runtime/src/ompt-specific.h

 ompt_task_info_t *__ompt_get_task_info_object(int depth);
 
 int __ompt_get_parallel_info_internal(int ancestor_level,
                                       ompt_data_t **parallel_data,
                                       int *team_size);
 
 int __ompt_get_task_info_internal(int ancestor_level, int *type,
                                   ompt_data_t **task_data,
-                                  ompt_frame_t **task_frame,
+                                  omp_frame_t **task_frame,
                                   ompt_data_t **parallel_data, int *thread_num);
 
 ompt_data_t *__ompt_get_thread_data_internal();
 
 static uint64_t __ompt_get_get_unique_id_internal();
 
 /*****************************************************************************
  * macros

openmp/trunk/runtime/src/ompt-specific.cpp

 }
 
 //----------------------------------------------------------
 // task support
 //----------------------------------------------------------
 
 int __ompt_get_task_info_internal(int ancestor_level, int *type,
                                   ompt_data_t **task_data,
-                                  ompt_frame_t **task_frame,
+                                  omp_frame_t **task_frame,
                                   ompt_data_t **parallel_data,
                                   int *thread_num) {
   if (__kmp_get_gtid() < 0)
     return 0;
 
   if (ancestor_level < 0)
     return 0;
 

openmp/trunk/runtime/test/ompt/callback.h

 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;
+  omp_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
case ompt_scope_end:
       printf("%" PRIu64 ": ompt_event_master_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;
   }
 }
 
 static void
 on_ompt_callback_parallel_begin(
   ompt_data_t *encountering_task_data,
-  const ompt_frame_t *encountering_task_frame,
+  const omp_frame_t *encountering_task_frame,
   ompt_data_t* parallel_data,
   uint32_t requested_team_size,
   ompt_invoker_t invoker,
   const void *codeptr_ra)
 {
   if(parallel_data->ptr)
     printf("0: parallel_data initially not null\n");
   parallel_data->value = ompt_get_unique_id();
   printf("%" PRIu64 ": ompt_event_parallel_begin: parent_task_id=%" PRIu64 ", parent_task_frame.exit=%p, parent_task_frame.reenter=%p, parallel_id=%" PRIu64 ", requested_team_size=%" PRIu32 ", codeptr_ra=%p, invoker=%d\n", ompt_get_thread_data()->value, encountering_task_data->value, encountering_task_frame->exit_frame, encountering_task_frame->enter_frame, parallel_data->value, requested_team_size, codeptr_ra, invoker);
 }
 
 static void
 on_ompt_callback_parallel_end(
   ompt_data_t *parallel_data,
   ompt_data_t *encountering_task_data,
   ompt_invoker_t invoker,
   const void *codeptr_ra)
 {
   printf("%" PRIu64 ": ompt_event_parallel_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", invoker=%d, codeptr_ra=%p\n", ompt_get_thread_data()->value, 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,
+    const omp_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();

 
 static int
 on_ompt_callback_control_tool(
   uint64_t command,
   uint64_t modifier,
   void *arg,
   const void *codeptr_ra)
 {
-  ompt_frame_t* omptTaskFrame;
+  omp_frame_t* omptTaskFrame;
   ompt_get_task_info(0, NULL, (ompt_data_t**) NULL, &omptTaskFrame, NULL, NULL);
   printf("%" PRIu64 ": 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, omptTaskFrame->enter_frame);
   return 0; //success
 }
 
 #define register_callback_t(name, type)                       \
 do{                                                           \
   type f_##name = &on_##name;                                 \