[OMPT] Remove OMPT idle callback

[sconvent]

Summary

The idle callback was removed from the spec.
This removes it from the implementation.

[hbae]

LGTM

[protze.joachim]

Was hold back from 7.0, to keep the implementation according to TR6.

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

#define FOREACH_OMPT_EVENT(macro)                                                                                        \
     macro (ompt_callback_mutex_acquire,     ompt_callback_mutex_acquire_t,     26) /* mutex acquire                   */ \
     macro (ompt_callback_mutex_acquired,    ompt_callback_mutex_t,             27) /* mutex acquired                  */ \
                                                                                                                          \
     macro (ompt_callback_nest_lock,         ompt_callback_nest_lock_t,         28) /* nest lock                       */ \
                                                                                                                          \
     macro (ompt_callback_flush,             ompt_callback_flush_t,             29) /* after executing flush           */ \
                                                                                                                          \
     macro (ompt_callback_cancel,            ompt_callback_cancel_t,            30) /* cancel innermost binding region */ \
-    macro (ompt_callback_idle,              ompt_callback_idle_t,              31) /* begin or end idle state         */
 
 
 
 /*****************************************************************************
  * data types
  *****************************************************************************/
 
 /*---------------------

 
 typedef void (*ompt_callback_master_t) (
     ompt_scope_endpoint_t endpoint,       /* endpoint of master region           */
     ompt_data_t *parallel_data,           /* data of parallel region             */
     ompt_data_t *task_data,               /* data of task                        */
     const void *codeptr_ra                /* return address of runtime call      */
 );
 
-typedef void (*ompt_callback_idle_t) (
-    ompt_scope_endpoint_t endpoint        /* endpoint of idle time               */
-);
-
 typedef enum ompt_work_type_t {
     ompt_work_loop            = 1,
     ompt_work_sections        = 2,
     ompt_work_single_executor = 3,
     ompt_work_single_other    = 4,
     ompt_work_workshare       = 5,
     ompt_work_distribute      = 6,
     ompt_work_taskloop        = 7

openmp/trunk/runtime/src/kmp_wait_release.h

if (ompt_enabled.ompt_callback_sync_region) {
           ompt_sync_region_barrier, ompt_scope_end, NULL, tId, codeptr);
     }
 #endif
     if (!KMP_MASTER_TID(ds_tid)) {
       if (ompt_enabled.ompt_callback_implicit_task) {
         ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
             ompt_scope_end, NULL, tId, 0, ds_tid);
       }
-#if OMPT_OPTIONAL
-      if (ompt_enabled.ompt_callback_idle) {
-        ompt_callbacks.ompt_callback(ompt_callback_idle)(ompt_scope_begin);
-      }
-#endif
       // return to idle state
       this_thr->th.ompt_thread_info.state = omp_state_idle;
     } else {
       this_thr->th.ompt_thread_info.state = omp_state_overhead;
     }
   }
 }
 #endif
if (!final_spin || ompt_entry_state != omp_state_wait_barrier_implicit ||
       } else {
         pId = OMPT_CUR_TEAM_DATA(this_thr);
         tId = OMPT_CUR_TASK_DATA(this_thr);
       }
     } else {
       pId = NULL;
       tId = &(this_thr->th.ompt_thread_info.task_data);
     }
-#if OMPT_OPTIONAL
-    if (ompt_entry_state == omp_state_idle) {
-      if (ompt_enabled.ompt_callback_idle) {
-        ompt_callbacks.ompt_callback(ompt_callback_idle)(ompt_scope_begin);
-      }
-    } else
-#endif
         if (final_spin && (__kmp_tasking_mode == tskm_immediate_exec ||
                            this_thr->th.th_task_team == NULL)) {
       // implicit task is done. Either no taskqueue, or task-team finished
       __ompt_implicit_task_end(this_thr, ompt_entry_state, tId, pId);
     }
   }
 #endif
 
#if OMPT_SUPPORT
   if (ompt_enabled.enabled && ompt_exit_state != omp_state_undefined) {
 #if OMPT_OPTIONAL
     if (final_spin) {
       __ompt_implicit_task_end(this_thr, ompt_exit_state, tId, pId);
       ompt_exit_state = this_thr->th.ompt_thread_info.state;
     }
 #endif
     if (ompt_exit_state == omp_state_idle) {
-#if OMPT_OPTIONAL
-      if (ompt_enabled.ompt_callback_idle) {
-        ompt_callbacks.ompt_callback(ompt_callback_idle)(ompt_scope_end);
-      }
-#endif
       this_thr->th.ompt_thread_info.state = omp_state_overhead;
     }
   }
 #endif
 #if KMP_STATS_ENABLED
   // If we were put into idle state, pop that off the state stack
   if (KMP_GET_THREAD_STATE() == IDLE) {
     KMP_POP_PARTITIONED_TIMER();

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

 #define ompt_callback_mutex_acquire_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 #define ompt_callback_mutex_acquired_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 #define ompt_callback_nest_lock_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_flush_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_cancel_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
-#define ompt_callback_idle_implemented ompt_event_MAY_ALWAYS_OPTIONAL
-
 #endif

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

else if(flags & ompt_cancel_detected)
     second_flag_value = ompt_cancel_flag_t_values[5];
   else if(flags & ompt_cancel_discarded_task)
     second_flag_value = ompt_cancel_flag_t_values[6];
 
   printf("%" PRIu64 ": ompt_event_cancel: task_data=%" PRIu64 ", flags=%s|%s=%" PRIu32 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, task_data->value, first_flag_value, second_flag_value, flags,  codeptr_ra);
 }
 
 static void
-on_ompt_callback_idle(
-  ompt_scope_endpoint_t endpoint)
-{
-  switch(endpoint)
-  {
-    case ompt_scope_begin:
-      printf("%" PRIu64 ": ompt_event_idle_begin:\n", ompt_get_thread_data()->value);
-      break;
-    case ompt_scope_end:
-      printf("%" PRIu64 ": ompt_event_idle_end:\n", ompt_get_thread_data()->value);
-      break;
-  }
-}
-
-static void
 on_ompt_callback_implicit_task(
     ompt_scope_endpoint_t endpoint,
     ompt_data_t *parallel_data,
     ompt_data_t *task_data,
     unsigned int team_size,
     unsigned int thread_num)
 {
   switch(endpoint)
int ompt_initialize(
   register_callback_t(ompt_callback_mutex_acquired, ompt_callback_mutex_t);
   register_callback_t(ompt_callback_mutex_released, ompt_callback_mutex_t);
   register_callback(ompt_callback_nest_lock);
   register_callback(ompt_callback_sync_region);
   register_callback_t(ompt_callback_sync_region_wait, ompt_callback_sync_region_t);
   register_callback(ompt_callback_control_tool);
   register_callback(ompt_callback_flush);
   register_callback(ompt_callback_cancel);
-  register_callback(ompt_callback_idle);
   register_callback(ompt_callback_implicit_task);
   register_callback_t(ompt_callback_lock_init, ompt_callback_mutex_acquire_t);
   register_callback_t(ompt_callback_lock_destroy, ompt_callback_mutex_t);
   register_callback(ompt_callback_work);
   register_callback(ompt_callback_master);
   register_callback(ompt_callback_parallel_begin);
   register_callback(ompt_callback_parallel_end);
   register_callback(ompt_callback_task_create);

openmp/trunk/runtime/test/ompt/misc/idle.c

-// RUN: %libomp-compile-and-run | FileCheck %s
-// REQUIRES: ompt
-#include "callback.h"
-#include <omp.h>
-
-int main()
-{
-  int x = 0;
-  #pragma omp parallel num_threads(3)
-  {
-    #pragma omp atomic
-    x++;
-  }
-  #pragma omp parallel num_threads(2)
-  {
-    #pragma omp atomic
-    x++;
-  }
-
-
-  printf("x=%d\n", x);
-
-  // Check if libomp supports the callbacks for this test.
-  // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_idle'
-
-  // CHECK: 0: NULL_POINTER=[[NULL:.*$]]
-
-  // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_idle_begin:
-  // CHECK: {{^}}[[THREAD_ID]]: ompt_event_idle_end:
-
-  return 0;
-}