Tidy statistics collection

[jcownie]

Summary

This removes some statistics counters and timers which were not used,
adds new counters and timers for some language features that were not
monitored previously and separates the counters and timers into those
which are of interest for investigating user code and those which are
only of interest to the developer of the runtime itself.
The runtime developer statistics are now ony collected if the
additional #define KMP_DEVELOPER_STATS is set.

Additional user statistics which are now collected include

Count of nested parallelism (omp parallel inside a parallel
region)
Count of omp distribute occurrences
Count of omp teams occurrences
Counts of task related statistics (taskyield, task execution, task
cancellation, task steal)
Values passed to omp_set_numtheads

None of this affects code compiled without stats gathering enabled,
which is the normal library build mode.

[hfinkel]

LGTM.

[AndreyChurbanov]

runtime/src/z_Linux_util.c

1904 ↗

(On Diff #31333)

Should this counter be placed in kmp_resume_template instead? The kmp_resume_monitor works at shutdown time, that does not correlate well with "USER_resume" event.

[jlpeyton]

LGTM too.

runtime/src/z_Linux_util.c

1904 ↗

(On Diff #31333)

I've moved this to kmp_resume_template() in the committed version.

openmp/trunk/runtime/CMakeLists.txt

 # - stats-gathering enables OpenMP stats where things like the number of
 # parallel regions, clock ticks spent in particular openmp regions are recorded.
 # TODO: Make this a real feature check
 set(LIBOMP_STATS FALSE CACHE BOOL
   "Stats-Gathering functionality?")
 if(LIBOMP_STATS AND (NOT LIBOMP_HAVE_STATS))
   libomp_error_say("Stats-gathering functionality requested but not available")
 endif()
+# The stats functionality requires the std c++ library
+if(LIBOMP_STATS)
+  set(LIBOMP_USE_STDCPPLIB TRUE)
+endif()
 
 # OMPT-support
 # TODO: Make this a real feature check
 set(LIBOMP_OMPT_SUPPORT FALSE CACHE BOOL
   "OMPT-support?")
 set(LIBOMP_OMPT_BLAME TRUE CACHE BOOL
   "OMPT-blame?")
 set(LIBOMP_OMPT_TRACE TRUE CACHE BOOL

openmp/trunk/runtime/src/CMakeLists.txt

 # Let the compiler handle the assembly files on Unix-like systems
 if(NOT WIN32)
   set_source_files_properties(${LIBOMP_ASMFILES} PROPERTIES LANGUAGE C)
 endif()
 
 # Remove any cmake-automatic linking of the standard C++ library.
 # We neither need (nor want) the standard C++ library dependency even though we compile c++ files.
 if(NOT ${LIBOMP_USE_STDCPPLIB})
+  set(LIBOMP_LINKER_LANGUAGE C)
   set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES)
+else()
+  set(LIBOMP_LINKER_LANGUAGE CXX)
 endif()
 
 # Add the OpenMP library
 libomp_get_ldflags(LIBOMP_CONFIGURED_LDFLAGS)
 add_library(omp SHARED ${LIBOMP_SOURCE_FILES})
 set_target_properties(omp PROPERTIES
   PREFIX "" SUFFIX "" OUTPUT_NAME "${LIBOMP_LIB_FILE}"
   LINK_FLAGS "${LIBOMP_CONFIGURED_LDFLAGS}"
-  LINKER_LANGUAGE C # use C Compiler for linking step
+  LINKER_LANGUAGE ${LIBOMP_LINKER_LANGUAGE}
   SKIP_BUILD_RPATH true # have Mac linker -install_name just be "-install_name libomp.dylib"
 )
 
 # Linking command will include libraries in LIBOMP_CONFIGURED_LIBFLAGS
 libomp_get_libflags(LIBOMP_CONFIGURED_LIBFLAGS)
 target_link_libraries(omp ${LIBOMP_CONFIGURED_LIBFLAGS} ${CMAKE_DL_LIBS})
 
 # Create *.inc and omp.h before compiling any sources

openmp/trunk/runtime/src/kmp_barrier.cpp

 // ---------------------------- Barrier Algorithms ----------------------------
 
 // Linear Barrier
 static void
 __kmp_linear_barrier_gather(enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
                             void (*reduce)(void *, void *)
                             USE_ITT_BUILD_ARG(void * itt_sync_obj) )
 {
-    KMP_TIME_BLOCK(KMP_linear_gather);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_linear_gather);
     register kmp_team_t *team = this_thr->th.th_team;
     register kmp_bstate_t *thr_bar = & this_thr->th.th_bar[bt].bb;
     register kmp_info_t **other_threads = team->t.t_threads;
 
     KA_TRACE(20, ("__kmp_linear_barrier_gather: T#%d(%d:%d) enter for barrier type %d\n",
                   gtid, team->t.t_id, tid, bt));
     KMP_DEBUG_ASSERT(this_thr == other_threads[this_thr->th.th_info.ds.ds_tid]);
 
KA_TRACE(20, ("__kmp_linear_barrier_gather: T#%d(%d:%d) exit for barrier type %d\n",
                   gtid, team->t.t_id, tid, bt));
 }
 
 static void
 __kmp_linear_barrier_release(enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
                              int propagate_icvs
                              USE_ITT_BUILD_ARG(void *itt_sync_obj) )
 {
-    KMP_TIME_BLOCK(KMP_linear_release);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_linear_release);
     register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
     register kmp_team_t *team;
 
     if (KMP_MASTER_TID(tid)) {
         register unsigned int i;
         register kmp_uint32 nproc = this_thr->th.th_team_nproc;
         register kmp_info_t **other_threads;
 
         team = __kmp_threads[gtid]->th.th_team;
         KMP_DEBUG_ASSERT(team != NULL);
         other_threads = team->t.t_threads;
 
         KA_TRACE(20, ("__kmp_linear_barrier_release: T#%d(%d:%d) master enter for barrier type %d\n",
                       gtid, team->t.t_id, tid, bt));
 
         if (nproc > 1) {
 #if KMP_BARRIER_ICV_PUSH
-            KMP_START_EXPLICIT_TIMER(USER_icv_copy);
+            {
+                KMP_TIME_DEVELOPER_BLOCK(USER_icv_copy);
                 if (propagate_icvs) {
                     ngo_load(&team->t.t_implicit_task_taskdata[0].td_icvs);
                     for (i=1; i<nproc; ++i) {
                         __kmp_init_implicit_task(team->t.t_ident, team->t.t_threads[i], team, i, FALSE);
                         ngo_store_icvs(&team->t.t_implicit_task_taskdata[i].td_icvs,
                                        &team->t.t_implicit_task_taskdata[0].td_icvs);
                     }
                     ngo_sync();
                 }
-            KMP_STOP_EXPLICIT_TIMER(USER_icv_copy);
+            }
 #endif // KMP_BARRIER_ICV_PUSH
 
             // Now, release all of the worker threads
             for (i=1; i<nproc; ++i) {
 #if KMP_CACHE_MANAGE
                 // Prefetch next thread's go flag
                 if (i+1 < nproc)
                     KMP_CACHE_PREFETCH(&other_threads[i+1]->th.th_bar[bt].bb.b_go);

 }
 
 // Tree barrier
 static void
 __kmp_tree_barrier_gather(enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
                           void (*reduce)(void *, void *)
                           USE_ITT_BUILD_ARG(void *itt_sync_obj) )
 {
-    KMP_TIME_BLOCK(KMP_tree_gather);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_tree_gather);
     register kmp_team_t *team = this_thr->th.th_team;
     register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
     register kmp_info_t **other_threads = team->t.t_threads;
     register kmp_uint32 nproc = this_thr->th.th_team_nproc;
     register kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt];
     register kmp_uint32 branch_factor = 1 << branch_bits;
     register kmp_uint32 child;
     register kmp_uint32 child_tid;
KA_TRACE(20, ("__kmp_tree_barrier_gather: T#%d(%d:%d) exit for barrier type %d\n",
                   gtid, team->t.t_id, tid, bt));
 }
 
 static void
 __kmp_tree_barrier_release(enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
                            int propagate_icvs
                            USE_ITT_BUILD_ARG(void *itt_sync_obj) )
 {
-    KMP_TIME_BLOCK(KMP_tree_release);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_tree_release);
     register kmp_team_t *team;
     register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
     register kmp_uint32 nproc;
     register kmp_uint32 branch_bits = __kmp_barrier_release_branch_bits[bt];
     register kmp_uint32 branch_factor = 1 << branch_bits;
     register kmp_uint32 child;
     register kmp_uint32 child_tid;
 
if (child_tid < nproc) {
             register kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
 #if KMP_CACHE_MANAGE
             // Prefetch next thread's go count
             if (child+1 <= branch_factor && child_tid+1 < nproc)
                 KMP_CACHE_PREFETCH(&other_threads[child_tid+1]->th.th_bar[bt].bb.b_go);
 #endif /* KMP_CACHE_MANAGE */
 
 #if KMP_BARRIER_ICV_PUSH
-            KMP_START_EXPLICIT_TIMER(USER_icv_copy);
+            {
+                KMP_TIME_DEVELOPER_BLOCK(USER_icv_copy);
                 if (propagate_icvs) {
                     __kmp_init_implicit_task(team->t.t_ident, team->t.t_threads[child_tid],
                                              team, child_tid, FALSE);
                     copy_icvs(&team->t.t_implicit_task_taskdata[child_tid].td_icvs,
                               &team->t.t_implicit_task_taskdata[0].td_icvs);
                 }
-            KMP_STOP_EXPLICIT_TIMER(USER_icv_copy);
+            }
 #endif // KMP_BARRIER_ICV_PUSH
             KA_TRACE(20, ("__kmp_tree_barrier_release: T#%d(%d:%d) releasing T#%d(%d:%u)"
                           "go(%p): %u => %u\n", gtid, team->t.t_id, tid,
                           __kmp_gtid_from_tid(child_tid, team), team->t.t_id,
                           child_tid, &child_bar->b_go, child_bar->b_go,
                           child_bar->b_go + KMP_BARRIER_STATE_BUMP));
             // Release child from barrier
             kmp_flag_64 flag(&child_bar->b_go, child_thr);

 
 
 // Hyper Barrier
 static void
 __kmp_hyper_barrier_gather(enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
                            void (*reduce)(void *, void *)
                            USE_ITT_BUILD_ARG(void *itt_sync_obj) )
 {
-    KMP_TIME_BLOCK(KMP_hyper_gather);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_hyper_gather);
     register kmp_team_t *team = this_thr->th.th_team;
     register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
     register kmp_info_t **other_threads = team->t.t_threads;
     register kmp_uint new_state = KMP_BARRIER_UNUSED_STATE;
     register kmp_uint32 num_threads = this_thr->th.th_team_nproc;
     register kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt];
     register kmp_uint32 branch_factor = 1 << branch_bits;
     register kmp_uint32 offset;

 
 // The reverse versions seem to beat the forward versions overall
 #define KMP_REVERSE_HYPER_BAR
 static void
 __kmp_hyper_barrier_release(enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
                             int propagate_icvs
                             USE_ITT_BUILD_ARG(void *itt_sync_obj) )
 {
-    KMP_TIME_BLOCK(KMP_hyper_release);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_hyper_release);
     register kmp_team_t    *team;
     register kmp_bstate_t  *thr_bar       = & this_thr -> th.th_bar[ bt ].bb;
     register kmp_info_t   **other_threads;
     register kmp_uint32     num_threads;
     register kmp_uint32     branch_bits   = __kmp_barrier_release_branch_bits[ bt ];
     register kmp_uint32     branch_factor = 1 << branch_bits;
     register kmp_uint32     child;
     register kmp_uint32     child_tid;
__kmp_init_hierarchical_barrier_thread(enum barrier_type bt, kmp_bstate_t *thr_bar, kmp_uint32 nproc,
     return retval;
 }
 
 static void
 __kmp_hierarchical_barrier_gather(enum barrier_type bt, kmp_info_t *this_thr,
                                   int gtid, int tid, void (*reduce) (void *, void *)
                                   USE_ITT_BUILD_ARG(void * itt_sync_obj) )
 {
-    KMP_TIME_BLOCK(KMP_hier_gather);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_hier_gather);
     register kmp_team_t *team = this_thr->th.th_team;
     register kmp_bstate_t *thr_bar = & this_thr->th.th_bar[bt].bb;
     register kmp_uint32 nproc = this_thr->th.th_team_nproc;
     register kmp_info_t **other_threads = team->t.t_threads;
     register kmp_uint64 new_state;
 
     int level = team->t.t_level;
     if (other_threads[0]->th.th_teams_microtask)    // are we inside the teams construct?
KA_TRACE(20, ("__kmp_hierarchical_barrier_gather: T#%d(%d:%d) exit for barrier type %d\n",
                   gtid, team->t.t_id, tid, bt));
 }
 
 static void
 __kmp_hierarchical_barrier_release(enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
                                    int propagate_icvs
                                    USE_ITT_BUILD_ARG(void * itt_sync_obj) )
 {
-    KMP_TIME_BLOCK(KMP_hier_release);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_hier_release);
     register kmp_team_t *team;
     register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
     register kmp_uint32 nproc;
     bool team_change = false; // indicates on-core barrier shouldn't be used
 
     if (KMP_MASTER_TID(tid)) {
         team = __kmp_threads[gtid]->th.th_team;
         KMP_DEBUG_ASSERT(team != NULL);

 // Internal function to do a barrier.
 /* If is_split is true, do a split barrier, otherwise, do a plain barrier
    If reduce is non-NULL, do a split reduction barrier, otherwise, do a split barrier
    Returns 0 if master thread, 1 if worker thread.  */
 int
 __kmp_barrier(enum barrier_type bt, int gtid, int is_split, size_t reduce_size,
               void *reduce_data, void (*reduce)(void *, void *))
 {
-    KMP_TIME_BLOCK(KMP_barrier);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_barrier);
     register int tid = __kmp_tid_from_gtid(gtid);
     register kmp_info_t *this_thr = __kmp_threads[gtid];
     register kmp_team_t *team = this_thr->th.th_team;
     register int status = 0;
     ident_t *loc = __kmp_threads[gtid]->th.th_ident;
 #if OMPT_SUPPORT
     ompt_task_id_t my_task_id;
     ompt_parallel_id_t my_parallel_id;
#endif
 
     return status;
 }
 
 
 void
 __kmp_end_split_barrier(enum barrier_type bt, int gtid)
 {
-    KMP_TIME_BLOCK(KMP_end_split_barrier);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_end_split_barrier);
     int tid = __kmp_tid_from_gtid(gtid);
     kmp_info_t *this_thr = __kmp_threads[gtid];
     kmp_team_t *team = this_thr->th.th_team;
 
     if (!team->t.t_serialized) {
         if (KMP_MASTER_GTID(gtid)) {
             switch (__kmp_barrier_release_pattern[bt]) {
             case bp_hyper_bar: {
if (!team->t.t_serialized) {
         }
     }
 }
 
 
 void
 __kmp_join_barrier(int gtid)
 {
-    KMP_TIME_BLOCK(KMP_join_barrier);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_join_barrier);
     register kmp_info_t *this_thr = __kmp_threads[gtid];
     register kmp_team_t *team;
     register kmp_uint nproc;
     kmp_info_t *master_thread;
     int tid;
 #ifdef KMP_DEBUG
     int team_id;
 #endif /* KMP_DEBUG */

 #endif
 }
 
 
 // TODO release worker threads' fork barriers as we are ready instead of all at once
 void
 __kmp_fork_barrier(int gtid, int tid)
 {
-    KMP_TIME_BLOCK(KMP_fork_barrier);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_fork_barrier);
     kmp_info_t *this_thr = __kmp_threads[gtid];
     kmp_team_t *team = (tid == 0) ? this_thr->th.th_team : NULL;
 #if USE_ITT_BUILD
     void * itt_sync_obj = NULL;
 #endif /* USE_ITT_BUILD */
 
     KA_TRACE(10, ("__kmp_fork_barrier: T#%d(%d:%d) has arrived\n",
                   gtid, (team != NULL) ? team->t.t_id : -1, tid));

 
 
 #if KMP_BARRIER_ICV_PULL
     /* Master thread's copy of the ICVs was set up on the implicit taskdata in
        __kmp_reinitialize_team. __kmp_fork_call() assumes the master thread's implicit task has
        this data before this function is called. We cannot modify __kmp_fork_call() to look at
        the fixed ICVs in the master's thread struct, because it is not always the case that the
        threads arrays have been allocated when __kmp_fork_call() is executed. */
-    KMP_START_EXPLICIT_TIMER(USER_icv_copy);
+    {
+        KMP_TIME_DEVELOPER_BLOCK(USER_icv_copy);
         if (!KMP_MASTER_TID(tid)) {  // master thread already has ICVs
             // Copy the initial ICVs from the master's thread struct to the implicit task for this tid.
             KA_TRACE(10, ("__kmp_fork_barrier: T#%d(%d) is PULLing ICVs\n", gtid, tid));
             __kmp_init_implicit_task(team->t.t_ident, team->t.t_threads[tid], team, tid, FALSE);
             copy_icvs(&team->t.t_implicit_task_taskdata[tid].td_icvs,
                       &team->t.t_threads[0]->th.th_bar[bs_forkjoin_barrier].bb.th_fixed_icvs);
         }
-    KMP_STOP_EXPLICIT_TIMER(USER_icv_copy);
+    }
 #endif // KMP_BARRIER_ICV_PULL
 
     if (__kmp_tasking_mode != tskm_immediate_exec) {
         __kmp_task_team_sync(this_thr, team);
     }
 
 #if OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
     kmp_proc_bind_t proc_bind = team->t.t_proc_bind;

 #endif /* USE_ITT_BUILD && USE_ITT_NOTIFY */
     KA_TRACE(10, ("__kmp_fork_barrier: T#%d(%d:%d) is leaving\n", gtid, team->t.t_id, tid));
 }
 
 
 void
 __kmp_setup_icv_copy(kmp_team_t *team, int new_nproc, kmp_internal_control_t *new_icvs, ident_t *loc )
 {
-    KMP_TIME_BLOCK(KMP_setup_icv_copy);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_setup_icv_copy);
 
     KMP_DEBUG_ASSERT(team && new_nproc && new_icvs);
     KMP_DEBUG_ASSERT((!TCR_4(__kmp_init_parallel)) || new_icvs->nproc);
 
     /* Master thread's copy of the ICVs was set up on the implicit taskdata in
        __kmp_reinitialize_team. __kmp_fork_call() assumes the master thread's implicit task has
        this data before this function is called. */
 #if KMP_BARRIER_ICV_PULL

openmp/trunk/runtime/src/kmp_cancel.cpp

if (__kmp_omp_cancellation) {
                     //       this_team->t.t_cancel_request, &(this_team->t.t_cancel_request));
                     // we do not have a cancellation request in this team or we do have one
                     // that matches the current request -> cancel
                     return 1 /* true */;
                 }
                 break;
             }
         case cancel_taskgroup:
-            // cancellation requests for parallel and worksharing constructs
+            // cancellation requests for a task group
             // are handled through the taskgroup structure
             {
                 kmp_taskdata_t*  task; 
                 kmp_taskgroup_t* taskgroup;
                 
                 task = this_thr->th.th_current_task;
                 KMP_DEBUG_ASSERT( task );
                 
if (__kmp_omp_cancellation) {
                 else {
                     // we do not have a cancellation request pending, so we just
                     // ignore this cancellation point
                     return 0;
                 }
                 break;
             }
         case cancel_taskgroup:
-            // cancellation requests for parallel and worksharing constructs
+            // cancellation requests for a task group
             // are handled through the taskgroup structure
             {
                 kmp_taskdata_t*  task; 
                 kmp_taskgroup_t* taskgroup;
                 
                 task = this_thr->th.th_current_task;
                 KMP_DEBUG_ASSERT( task );
                 

openmp/trunk/runtime/src/kmp_csupport.c

 @param microtask  pointer to callback routine consisting of outlined parallel construct
 @param ...  pointers to shared variables that aren't global
 
 Do the actual fork and call the microtask in the relevant number of threads.
 */
 void
 __kmpc_fork_call(ident_t *loc, kmp_int32 argc, kmpc_micro microtask, ...)
 {
+  int         gtid = __kmp_entry_gtid();
+
+#if (KMP_STATS_ENABLED)  
+  int inParallel = __kmpc_in_parallel(loc);
+  if (inParallel)
+  {
+      KMP_COUNT_BLOCK(OMP_NESTED_PARALLEL);
+  }
+  else
+  {
       KMP_STOP_EXPLICIT_TIMER(OMP_serial);
       KMP_COUNT_BLOCK(OMP_PARALLEL);
-  int         gtid = __kmp_entry_gtid();
+  }
+#endif
+
   // maybe to save thr_state is enough here
   {
     va_list     ap;
     va_start(   ap, microtask );
 
 #if OMPT_SUPPORT
     int tid = __kmp_tid_from_gtid( gtid );
     kmp_info_t *master_th = __kmp_threads[ gtid ];

 
 #if OMPT_SUPPORT
     if (ompt_status & ompt_status_track) {
         parent_team->t.t_implicit_task_taskdata[tid].
             ompt_task_info.frame.reenter_runtime_frame = 0;
     }
 #endif
   }
+#if (KMP_STATS_ENABLED)  
+  if (!inParallel)
       KMP_START_EXPLICIT_TIMER(OMP_serial);
+#endif
 }
 
 #if OMP_40_ENABLED
 /*!
 @ingroup PARALLEL
 @param loc source location information
 @param global_tid global thread number
 @param num_teams number of teams requested for the teams construct

 void
 __kmpc_fork_teams(ident_t *loc, kmp_int32 argc, kmpc_micro microtask, ...)
 {
     int         gtid = __kmp_entry_gtid();
     kmp_info_t *this_thr = __kmp_threads[ gtid ];
     va_list     ap;
     va_start(   ap, microtask );
 
+    KMP_COUNT_BLOCK(OMP_TEAMS);
+
     // remember teams entry point and nesting level
     this_thr->th.th_teams_microtask = microtask;
     this_thr->th.th_teams_level = this_thr->th.th_team->t.t_level; // AC: can be >0 on host
 
 #if OMPT_SUPPORT
     kmp_team_t *parent_team = this_thr->th.th_team;
     int tid = __kmp_tid_from_gtid( gtid );
     if (ompt_status & ompt_status_track) {
__kmpc_master(ident_t *loc, kmp_int32 global_tid)
     KMP_COUNT_BLOCK(OMP_MASTER);
     int status = 0;
 
     KC_TRACE( 10, ("__kmpc_master: called T#%d\n", global_tid ) );
 
     if( ! TCR_4( __kmp_init_parallel ) )
         __kmp_parallel_initialize();
 
-    if( KMP_MASTER_GTID( global_tid ))
+    if( KMP_MASTER_GTID( global_tid )) {
+        KMP_START_EXPLICIT_TIMER(OMP_master);
         status = 1;
+    }
 
 #if OMPT_SUPPORT && OMPT_TRACE
     if (status) {
         if ((ompt_status == ompt_status_track_callback) &&
             ompt_callbacks.ompt_callback(ompt_event_master_begin)) {
             kmp_info_t  *this_thr        = __kmp_threads[ global_tid ];
             kmp_team_t  *team            = this_thr -> th.th_team;
 

 that executes the <tt>master</tt> region.
 */
 void
 __kmpc_end_master(ident_t *loc, kmp_int32 global_tid)
 {
     KC_TRACE( 10, ("__kmpc_end_master: called T#%d\n", global_tid ) );
 
     KMP_DEBUG_ASSERT( KMP_MASTER_GTID( global_tid ));
+    KMP_STOP_EXPLICIT_TIMER(OMP_master);
 
 #if OMPT_SUPPORT && OMPT_TRACE
     kmp_info_t  *this_thr        = __kmp_threads[ global_tid ];
     kmp_team_t  *team            = this_thr -> th.th_team;
     if ((ompt_status == ompt_status_track_callback) &&
         ompt_callbacks.ompt_callback(ompt_event_master_end)) {
         int  tid = __kmp_tid_from_gtid( global_tid );
         ompt_callbacks.ompt_callback(ompt_event_master_end)(

 introduce an explicit barrier if it is required.
 */
 
 kmp_int32
 __kmpc_single(ident_t *loc, kmp_int32 global_tid)
 {
     KMP_COUNT_BLOCK(OMP_SINGLE);
     kmp_int32 rc = __kmp_enter_single( global_tid, loc, TRUE );
+    if(rc == TRUE) {
+        KMP_START_EXPLICIT_TIMER(OMP_single);
+    }
 
 #if OMPT_SUPPORT && OMPT_TRACE
     kmp_info_t *this_thr        = __kmp_threads[ global_tid ];
     kmp_team_t *team            = this_thr -> th.th_team;
     int tid = __kmp_tid_from_gtid( global_tid );
 
     if ((ompt_status == ompt_status_track_callback)) {
         if (rc) {

 Mark the end of a <tt>single</tt> construct.  This function should
 only be called by the thread that executed the block of code protected
 by the `single` construct.
 */
 void
 __kmpc_end_single(ident_t *loc, kmp_int32 global_tid)
 {
     __kmp_exit_single( global_tid );
+    KMP_STOP_EXPLICIT_TIMER(OMP_single);
 
 #if OMPT_SUPPORT && OMPT_TRACE
     kmp_info_t *this_thr        = __kmp_threads[ global_tid ];
     kmp_team_t *team            = this_thr -> th.th_team;
     int tid = __kmp_tid_from_gtid( global_tid );
 
     if ((ompt_status == ompt_status_track_callback) &&
         ompt_callbacks.ompt_callback(ompt_event_single_in_block_end)) {

 #endif // KMP_USE_DYNAMIC_LOCK
 }
 
 /* try to acquire the lock */
 int
 __kmpc_test_lock( ident_t *loc, kmp_int32 gtid, void **user_lock )
 {
     KMP_COUNT_BLOCK(OMP_test_lock);
-    KMP_TIME_BLOCK(OMP_test_lock);
 
 #if KMP_USE_DYNAMIC_LOCK
     int rc;
     int tag = DYNA_EXTRACT_D_TAG(user_lock);
 # if USE_ITT_BUILD
     __kmp_itt_lock_acquiring((kmp_user_lock_p)user_lock);
 # endif
 # if DYNA_USE_FAST_TAS

openmp/trunk/runtime/src/kmp_dispatch.cpp

#endif
     }
     pr->type_size = ___kmp_size_type; // remember the size of variables
     if ( kmp_ord_lower & schedule ) {
         pr->ordered = TRUE;
         schedule = (enum sched_type)(((int)schedule) - (kmp_ord_lower - kmp_sch_lower));
     } else {
         pr->ordered = FALSE;
     }
+
     if ( schedule == kmp_sch_static ) {
         schedule = __kmp_static;
     } else {
         if ( schedule == kmp_sch_runtime ) {
             // Use the scheduling specified by OMP_SCHEDULE (or __kmp_sch_default if not specified)
             schedule = team -> t.t_sched.r_sched_type;
             // Detail the schedule if needed (global controls are differentiated appropriately)
             if ( schedule == kmp_sch_guided_chunked ) {
if ( st != 1 ) {
             } else {   // lb >= ub
                 tc /= st;
             }
         }
     } else if ( ub < lb ) {        // st == 1
         tc = 0;                    // zero-trip
     }
 
+    // Any half-decent optimizer will remove this test when the blocks are empty since the macros expand to nothing
+    // when statistics are disabled.
+    if (schedule == __kmp_static)
+    {
+        KMP_COUNT_BLOCK(OMP_FOR_static);
+        KMP_COUNT_VALUE(FOR_static_iterations, tc);
+    }
+    else
+    {
+        KMP_COUNT_BLOCK(OMP_FOR_dynamic);
+        KMP_COUNT_VALUE(FOR_dynamic_iterations, tc);
+    }
+
     pr->u.p.lb = lb;
     pr->u.p.ub = ub;
     pr->u.p.st = st;
     pr->u.p.tc = tc;
 
     #if KMP_OS_WINDOWS
     pr->u.p.last_upper = ub + st;
     #endif /* KMP_OS_WINDOWS */
) {
 
     typedef typename traits_t< T >::unsigned_t  UT;
     typedef typename traits_t< T >::signed_t    ST;
     typedef typename traits_t< T >::floating_t  DBL;
 #if ( KMP_STATIC_STEAL_ENABLED && KMP_ARCH_X86_64 )
     static const int ___kmp_size_type = sizeof( UT );
 #endif
 
+    // This is potentially slightly misleading, schedule(runtime) will appear here even if the actual runtme schedule
+    // is static. (Which points out a disadavantage of schedule(runtime): even when static scheduling is used it costs
+    // more than a compile time choice to use static scheduling would.)
+    KMP_TIME_BLOCK(FOR_dynamic_scheduling);
+
     int                                   status;
     dispatch_private_info_template< T > * pr;
     kmp_info_t                          * th   = __kmp_threads[ gtid ];
     kmp_team_t                          * team = th -> th.th_team;
 
     KMP_DEBUG_ASSERT( p_lb && p_ub && p_st ); // AC: these cannot be NULL
     #ifdef KMP_DEBUG
     {

 __kmp_dist_get_bounds(
     ident_t                          *loc,
     kmp_int32                         gtid,
     kmp_int32                        *plastiter,
     T                                *plower,
     T                                *pupper,
     typename traits_t< T >::signed_t  incr
 ) {
-    KMP_COUNT_BLOCK(OMP_DISTR_FOR_dynamic);
     typedef typename traits_t< T >::unsigned_t  UT;
     typedef typename traits_t< T >::signed_t    ST;
     register kmp_uint32  team_id;
     register kmp_uint32  nteams;
     register UT          trip_count;
     register kmp_team_t *team;
     kmp_info_t * th;
 
) {
     // compute global trip count
     if( incr == 1 ) {
         trip_count = *pupper - *plower + 1;
     } else if(incr == -1) {
         trip_count = *plower - *pupper + 1;
     } else {
         trip_count = (ST)(*pupper - *plower) / incr + 1; // cast to signed to cover incr<0 case
     }
+
     if( trip_count <= nteams ) {
         KMP_DEBUG_ASSERT(
             __kmp_static == kmp_sch_static_greedy || \
             __kmp_static == kmp_sch_static_balanced
         ); // Unknown static scheduling type.
         // only some teams get single iteration, others get nothing
         if( team_id < trip_count ) {
             *pupper = *plower = *plower + team_id * incr;

 This function prepares the runtime to start a dynamically scheduled for loop, saving the loop arguments.
 These functions are all identical apart from the types of the arguments.
 */
 
 void
 __kmpc_dispatch_init_4( ident_t *loc, kmp_int32 gtid, enum sched_type schedule,
                         kmp_int32 lb, kmp_int32 ub, kmp_int32 st, kmp_int32 chunk )
 {
-    KMP_COUNT_BLOCK(OMP_FOR_dynamic);
     KMP_DEBUG_ASSERT( __kmp_init_serial );
     __kmp_dispatch_init< kmp_int32 >( loc, gtid, schedule, lb, ub, st, chunk, true );
 }
 /*!
 See @ref __kmpc_dispatch_init_4
 */
 void
 __kmpc_dispatch_init_4u( ident_t *loc, kmp_int32 gtid, enum sched_type schedule,
                         kmp_uint32 lb, kmp_uint32 ub, kmp_int32 st, kmp_int32 chunk )
 {
-    KMP_COUNT_BLOCK(OMP_FOR_dynamic);
     KMP_DEBUG_ASSERT( __kmp_init_serial );
     __kmp_dispatch_init< kmp_uint32 >( loc, gtid, schedule, lb, ub, st, chunk, true );
 }
 
 /*!
 See @ref __kmpc_dispatch_init_4
 */
 void
 __kmpc_dispatch_init_8( ident_t *loc, kmp_int32 gtid, enum sched_type schedule,
                         kmp_int64 lb, kmp_int64 ub,
                         kmp_int64 st, kmp_int64 chunk )
 {
-    KMP_COUNT_BLOCK(OMP_FOR_dynamic);
     KMP_DEBUG_ASSERT( __kmp_init_serial );
     __kmp_dispatch_init< kmp_int64 >( loc, gtid, schedule, lb, ub, st, chunk, true );
 }
 
 /*!
 See @ref __kmpc_dispatch_init_4
 */
 void
 __kmpc_dispatch_init_8u( ident_t *loc, kmp_int32 gtid, enum sched_type schedule,
                          kmp_uint64 lb, kmp_uint64 ub,
                          kmp_int64 st, kmp_int64 chunk )
 {
-    KMP_COUNT_BLOCK(OMP_FOR_dynamic);
     KMP_DEBUG_ASSERT( __kmp_init_serial );
     __kmp_dispatch_init< kmp_uint64 >( loc, gtid, schedule, lb, ub, st, chunk, true );
 }
 
 /*!
 See @ref __kmpc_dispatch_init_4
 
 Difference from __kmpc_dispatch_init set of functions is these functions
 are called for composite distribute parallel for construct. Thus before
 regular iterations dispatching we need to calc per-team iteration space.
 
 These functions are all identical apart from the types of the arguments.
 */
 void
 __kmpc_dist_dispatch_init_4( ident_t *loc, kmp_int32 gtid, enum sched_type schedule,
     kmp_int32 *p_last, kmp_int32 lb, kmp_int32 ub, kmp_int32 st, kmp_int32 chunk )
 {
-    KMP_COUNT_BLOCK(OMP_FOR_dynamic);
     KMP_DEBUG_ASSERT( __kmp_init_serial );
     __kmp_dist_get_bounds< kmp_int32 >( loc, gtid, p_last, &lb, &ub, st );
     __kmp_dispatch_init< kmp_int32 >( loc, gtid, schedule, lb, ub, st, chunk, true );
 }
 
 void
 __kmpc_dist_dispatch_init_4u( ident_t *loc, kmp_int32 gtid, enum sched_type schedule,
     kmp_int32 *p_last, kmp_uint32 lb, kmp_uint32 ub, kmp_int32 st, kmp_int32 chunk )
 {
-    KMP_COUNT_BLOCK(OMP_FOR_dynamic);
     KMP_DEBUG_ASSERT( __kmp_init_serial );
     __kmp_dist_get_bounds< kmp_uint32 >( loc, gtid, p_last, &lb, &ub, st );
     __kmp_dispatch_init< kmp_uint32 >( loc, gtid, schedule, lb, ub, st, chunk, true );
 }
 
 void
 __kmpc_dist_dispatch_init_8( ident_t *loc, kmp_int32 gtid, enum sched_type schedule,
     kmp_int32 *p_last, kmp_int64 lb, kmp_int64 ub, kmp_int64 st, kmp_int64 chunk )
 {
-    KMP_COUNT_BLOCK(OMP_FOR_dynamic);
     KMP_DEBUG_ASSERT( __kmp_init_serial );
     __kmp_dist_get_bounds< kmp_int64 >( loc, gtid, p_last, &lb, &ub, st );
     __kmp_dispatch_init< kmp_int64 >( loc, gtid, schedule, lb, ub, st, chunk, true );
 }
 
 void
 __kmpc_dist_dispatch_init_8u( ident_t *loc, kmp_int32 gtid, enum sched_type schedule,
     kmp_int32 *p_last, kmp_uint64 lb, kmp_uint64 ub, kmp_int64 st, kmp_int64 chunk )
 {
-    KMP_COUNT_BLOCK(OMP_FOR_dynamic);
     KMP_DEBUG_ASSERT( __kmp_init_serial );
     __kmp_dist_get_bounds< kmp_uint64 >( loc, gtid, p_last, &lb, &ub, st );
     __kmp_dispatch_init< kmp_uint64 >( loc, gtid, schedule, lb, ub, st, chunk, true );
 }
 
 /*!
 @param loc Source code location
 @param gtid Global thread id

openmp/trunk/runtime/src/kmp_runtime.c

 #if OMP_40_ENABLED
     int             active_level;
     int             teams_level;
 #endif
 #if KMP_NESTED_HOT_TEAMS
     kmp_hot_team_ptr_t **p_hot_teams;
 #endif
     { // KMP_TIME_BLOCK
-    KMP_TIME_BLOCK(KMP_fork_call);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_fork_call);
+    KMP_COUNT_VALUE(OMP_PARALLEL_args, argc);
 
     KA_TRACE( 20, ("__kmp_fork_call: enter T#%d\n", gtid ));
     if ( __kmp_stkpadding > 0 &&  __kmp_root[gtid] != NULL ) {
         /* Some systems prefer the stack for the root thread(s) to start with */
         /* some gap from the parent stack to prevent false sharing. */
         void *dummy = KMP_ALLOCA(__kmp_stkpadding);
         /* These 2 lines below are so this does not get optimized out */
         if ( __kmp_stkpadding > KMP_MAX_STKPADDING )
#endif
 
                 /* OMPT state */
                 master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
             } else {
                 exit_runtime_p = &dummy;
             }
 #endif
 
+            {
                 KMP_TIME_BLOCK(OMP_work);
                 __kmp_invoke_microtask( microtask, gtid, 0, argc, parent_team->t.t_argv
 #if OMPT_SUPPORT
                                         , exit_runtime_p
 #endif
                                         );
+            }
 
 #if OMPT_SUPPORT
             if (ompt_status & ompt_status_track) {
 #if OMPT_TRACE
                 lw_taskteam.ompt_task_info.frame.exit_runtime_frame = 0;
 
                 if ((ompt_status == ompt_status_track_callback) &&
                     ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
#endif /* OMP_40_ENABLED */
     }
 
     /* Invoke microtask for MASTER thread */
     KA_TRACE( 20, ("__kmp_fork_call: T#%d(%d:0) invoke microtask = %p\n",
                 gtid, team->t.t_id, team->t.t_pkfn ) );
     }  // END of timer KMP_fork_call block
 
     {
-        //KMP_TIME_BLOCK(OMP_work);
-        KMP_TIME_BLOCK(USER_master_invoke);
+        KMP_TIME_BLOCK(OMP_work);
+        // KMP_TIME_DEVELOPER_BLOCK(USER_master_invoke);
         if (! team->t.t_invoke( gtid )) {
             KMP_ASSERT2( 0, "cannot invoke microtask for MASTER thread" );
         }
     }
     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.  */
 

 
 void
 __kmp_join_call(ident_t *loc, int gtid, enum fork_context_e fork_context
 #if OMP_40_ENABLED
                , int exit_teams
 #endif /* OMP_40_ENABLED */
 )
 {
-    KMP_TIME_BLOCK(KMP_join_call);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_join_call);
     kmp_team_t     *team;
     kmp_team_t     *parent_team;
     kmp_info_t     *master_th;
     kmp_root_t     *root;
     int             master_active;
     int             i;
 
     KA_TRACE( 20, ("__kmp_join_call: enter T#%d\n", gtid ));
__kmp_set_num_threads( int new_nth, int gtid )
     KF_TRACE( 10, ("__kmp_set_num_threads: new __kmp_nth = %d\n", new_nth ));
     KMP_DEBUG_ASSERT( __kmp_init_serial );
 
     if (new_nth < 1)
         new_nth = 1;
     else if (new_nth > __kmp_max_nth)
         new_nth = __kmp_max_nth;
 
+    KMP_COUNT_VALUE(OMP_set_numthreads, new_nth);
     thread = __kmp_threads[gtid];
 
     __kmp_save_internal_controls( thread );
 
     set__nproc( thread, new_nth );
 
     //
     // If this omp_set_num_threads() call will cause the hot team size to be
#if OMPT_SUPPORT
     ompt_parallel_id_t ompt_parallel_id,
 #endif
 #if OMP_40_ENABLED
     kmp_proc_bind_t new_proc_bind,
 #endif
     kmp_internal_control_t *new_icvs,
     int argc USE_NESTED_HOT_ARG(kmp_info_t *master) )
 {
-    KMP_TIME_BLOCK(KMP_allocate_team);
+    KMP_TIME_DEVELOPER_BLOCK(KMP_allocate_team);
     int f;
     kmp_team_t *team;
     int use_hot_team = ! root->r.r_active;
     int level = 0;
 
     KA_TRACE( 20, ("__kmp_allocate_team: called\n"));
     KMP_DEBUG_ASSERT( new_nproc >=1 && argc >=0 );
     KMP_DEBUG_ASSERT( max_nproc >= new_nproc );
#if OMPT_SUPPORT
                     this_thr->th.ompt_thread_info.state = ompt_state_work_parallel;
                     // Initialize OMPT task id for implicit task.
                     int tid = __kmp_tid_from_gtid(gtid);
                     (*pteam)->t.t_implicit_task_taskdata[tid].ompt_task_info.task_id = 
                     __ompt_task_id_new(tid);
                 }
 #endif
 
-                KMP_STOP_EXPLICIT_TIMER(USER_launch_thread_loop);
+                KMP_STOP_DEVELOPER_EXPLICIT_TIMER(USER_launch_thread_loop);
                 {
-                    KMP_TIME_BLOCK(USER_worker_invoke);
+                    KMP_TIME_DEVELOPER_BLOCK(USER_worker_invoke);
                     rc = (*pteam)->t.t_invoke( gtid );
                 }
-                KMP_START_EXPLICIT_TIMER(USER_launch_thread_loop);
+                KMP_START_DEVELOPER_EXPLICIT_TIMER(USER_launch_thread_loop);
                 KMP_ASSERT( rc );
 
 #if OMPT_SUPPORT
                 if (ompt_status & ompt_status_track) {
                     /* no frame set while outside task */
                     int tid = __kmp_tid_from_gtid(gtid);
                     (*pteam)->t.t_implicit_task_taskdata[tid].ompt_task_info.frame.exit_runtime_frame = 0;
 
#if OMPT_TRACE
     if ((ompt_status == ompt_status_track_callback) &&
         ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)) {
         ompt_callbacks.ompt_callback(ompt_event_implicit_task_begin)(
             my_parallel_id, my_task_id);
     }
 #endif
 #endif
 
+    {
+        KMP_TIME_BLOCK(OMP_work);
         rc = __kmp_invoke_microtask( (microtask_t) TCR_SYNC_PTR(team->t.t_pkfn),
                                      gtid, tid, (int) team->t.t_argc, (void **) team->t.t_argv
 #if OMPT_SUPPORT
                                      , exit_runtime_p
 #endif
                                      );
+    }
 
 #if OMPT_SUPPORT && OMPT_TRACE
     if (ompt_status & ompt_status_track) {
         if ((ompt_status == ompt_status_track_callback) &&
             ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)) {
             ompt_callbacks.ompt_callback(ompt_event_implicit_task_end)(
                 my_parallel_id, my_task_id);
         }

openmp/trunk/runtime/src/kmp_sched.cpp

__kmp_for_static_init(
     kmp_int32                        *plastiter,
     T                                *plower,
     T                                *pupper,
     typename traits_t< T >::signed_t *pstride,
     typename traits_t< T >::signed_t  incr,
     typename traits_t< T >::signed_t  chunk
 ) {
     KMP_COUNT_BLOCK(OMP_FOR_static);
+    KMP_TIME_BLOCK (FOR_static_scheduling);
+
     typedef typename traits_t< T >::unsigned_t  UT;
     typedef typename traits_t< T >::signed_t    ST;
     /*  this all has to be changed back to TID and such.. */
     register kmp_int32   gtid = global_tid;
     register kmp_uint32  tid;
     register kmp_uint32  nth;
     register UT          trip_count;
     register kmp_team_t *team;

 #if OMPT_SUPPORT && OMPT_TRACE
         if ((ompt_status == ompt_status_track_callback) &&
             ompt_callbacks.ompt_callback(ompt_event_loop_begin)) {
             ompt_callbacks.ompt_callback(ompt_event_loop_begin)(
                 team_info->parallel_id, task_info->task_id,
                 team_info->microtask);
         }
 #endif
+        KMP_COUNT_VALUE (FOR_static_iterations, 0);
         return;
     }
 
     #if OMP_40_ENABLED
     if ( schedtype > kmp_ord_upper ) {
         // we are in DISTRIBUTE construct
         schedtype += kmp_sch_static - kmp_distribute_static;      // AC: convert to usual schedule type
         tid  = th->th.th_team->t.t_master_tid;
#endif
     }
 
     if ( __kmp_env_consistency_check ) {
         /* tripcount overflow? */
         if ( trip_count == 0 && *pupper != *plower ) {
             __kmp_error_construct( kmp_i18n_msg_CnsIterationRangeTooLarge, ct_pdo, loc );
         }
     }
+    KMP_COUNT_VALUE (FOR_static_iterations, trip_count);
 
     /* compute remaining parameters */
     switch ( schedtype ) {
     case kmp_sch_static:
         {
             if ( trip_count < nth ) {
                 KMP_DEBUG_ASSERT(
                     __kmp_static == kmp_sch_static_greedy || \
__kmp_dist_for_static_init(
     kmp_int32                        *plastiter,
     T                                *plower,
     T                                *pupper,
     T                                *pupperDist,
     typename traits_t< T >::signed_t *pstride,
     typename traits_t< T >::signed_t  incr,
     typename traits_t< T >::signed_t  chunk
 ) {
-    KMP_COUNT_BLOCK(OMP_DISTR_FOR_static);
+    KMP_COUNT_BLOCK(OMP_DISTRIBUTE);
     typedef typename traits_t< T >::unsigned_t  UT;
     typedef typename traits_t< T >::signed_t    ST;
     register kmp_uint32  tid;
     register kmp_uint32  nth;
     register kmp_uint32  team_id;
     register kmp_uint32  nteams;
     register UT          trip_count;
     register kmp_team_t *team;
) {
     // compute global trip count
     if( incr == 1 ) {
         trip_count = *pupper - *plower + 1;
     } else if(incr == -1) {
         trip_count = *plower - *pupper + 1;
     } else {
         trip_count = (ST)(*pupper - *plower) / incr + 1; // cast to signed to cover incr<0 case
     }
+
     *pstride = *pupper - *plower;  // just in case (can be unused)
     if( trip_count <= nteams ) {
         KMP_DEBUG_ASSERT(
             __kmp_static == kmp_sch_static_greedy || \
             __kmp_static == kmp_sch_static_balanced
         ); // Unknown static scheduling type.
         // only masters of some teams get single iteration, other threads get nothing
         if( team_id < trip_count && tid == 0 ) {

openmp/trunk/runtime/src/kmp_stats.h

 
 #include <limits>
 #include <math.h>
 #include <string>
 #include <stdint.h>
 #include <new> // placement new
 #include "kmp_stats_timing.h"
 
+/*
+ * Enable developer statistics here if you want them. They are more detailed than is useful for application characterisation and
+ * are intended for the runtime library developer.
+ */
+// #define KMP_DEVELOPER_STATS 1
 
 /*!
  * @ingroup STATS_GATHERING
  * \brief flags to describe the statistic ( timers or counter )
  *
 */
 class stats_flags_e {
     public:

  *
  * @param macro a user defined macro that takes three arguments - macro(COUNTER_NAME, flags, arg)
  * @param arg a user defined argument to send to the user defined macro
  *
  * \details A counter counts the occurrence of some event.
  * Each thread accumulates its own count, at the end of execution the counts are aggregated treating each thread
  * as a separate measurement. (Unless onlyInMaster is set, in which case there's only a single measurement).
  * The min,mean,max are therefore the values for the threads.
- * Adding the counter here and then putting in a KMP_BLOCK_COUNTER(name) is all you need to do.
+ * Adding the counter here and then putting a KMP_BLOCK_COUNTER(name) at the point you want to count is all you need to do.
  * All of the tables and printing is generated from this macro.
  * Format is "macro(name, flags, arg)"
  *
  * @ingroup STATS_GATHERING
 */
 #define KMP_FOREACH_COUNTER(macro, arg)                         \
     macro (OMP_PARALLEL, stats_flags_e::onlyInMaster, arg)      \
+    macro (OMP_NESTED_PARALLEL, 0, arg)                         \
     macro (OMP_FOR_static, 0, arg)                              \
     macro (OMP_FOR_dynamic, 0, arg)                             \
-    macro (OMP_DISTR_FOR_static, 0, arg)                        \
-    macro (OMP_DISTR_FOR_dynamic, 0, arg)                       \
+    macro (OMP_DISTRIBUTE, 0, arg)                              \
     macro (OMP_BARRIER, 0, arg)                                 \
     macro (OMP_CRITICAL,0, arg)                                 \
     macro (OMP_SINGLE, 0, arg)                                  \
     macro (OMP_MASTER, 0, arg)                                  \
+    macro (OMP_TEAMS, 0, arg)                                   \
     macro (OMP_set_lock, 0, arg)                                \
     macro (OMP_test_lock, 0, arg)                               \
-    macro (OMP_test_lock_failure, 0, arg)                       \
     macro (REDUCE_wait, 0, arg)                                 \
     macro (REDUCE_nowait, 0, arg)                               \
+    macro (OMP_TASKYIELD, 0, arg)                               \
+    macro (TASK_executed, 0, arg)                               \
+    macro (TASK_cancelled, 0, arg)                              \
+    macro (TASK_stolen, 0, arg)                                 \
     macro (LAST,0,arg)
 
+// OMP_PARALLEL_args      -- the number of arguments passed to a fork
+// FOR_static_iterations  -- Number of available parallel chunks of work in a static for
+// FOR_dynamic_iterations -- Number of available parallel chunks of work in a dynamic for
+//                           Both adjust for any chunking, so if there were an iteration count of 20 but a chunk size of 10, we'd record 2.
+
 /*!
  * \brief Add new timers under KMP_FOREACH_TIMER() macro in kmp_stats.h
  *
  * @param macro a user defined macro that takes three arguments - macro(TIMER_NAME, flags, arg)
  * @param arg a user defined argument to send to the user defined macro
  *
  * \details A timer collects multiple samples of some count in each thread and then finally aggregates over all the threads.
  * The count is normally a time (in ticks), hence the name "timer". (But can be any value, so we use this for "number of arguments passed to fork"
- * as well, or we could collect "loop iteration count" if we wanted to).
+ * as well).
  * For timers the threads are not significant, it's the individual observations that count, so the statistics are at that level.
  * Format is "macro(name, flags, arg)"
  *
- * @ingroup STATS_GATHERING
+ * @ingroup STATS_GATHERING2
  */
-#define KMP_FOREACH_TIMER(macro, arg)                                       \
-    macro (OMP_PARALLEL_args, stats_flags_e::onlyInMaster | stats_flags_e::noUnits, arg) \
-    macro (FOR_static_iterations, stats_flags_e::onlyInMaster | stats_flags_e::noUnits, arg) \
-    macro (FOR_dynamic_iterations, stats_flags_e::noUnits, arg)         \
+#define KMP_FOREACH_TIMER(macro, arg)                                   \
     macro (OMP_start_end, stats_flags_e::onlyInMaster, arg)             \
     macro (OMP_serial, stats_flags_e::onlyInMaster, arg)                \
     macro (OMP_work, 0, arg)                                            \
     macro (Total_work, stats_flags_e::synthesized, arg)                 \
-    macro (OMP_await_work, stats_flags_e::notInMaster, arg)             \
-    macro (Total_await_work, stats_flags_e::synthesized, arg)           \
     macro (OMP_barrier, 0, arg)                                         \
     macro (Total_barrier, stats_flags_e::synthesized, arg)              \
-    macro (OMP_test_lock, 0, arg)                                       \
+    macro (FOR_static_iterations, stats_flags_e::noUnits, arg)          \
     macro (FOR_static_scheduling, 0, arg)                               \
+    macro (FOR_dynamic_iterations, stats_flags_e::noUnits, arg)         \
     macro (FOR_dynamic_scheduling, 0, arg)                              \
-    macro (KMP_fork_call, 0, arg) \
-    macro (KMP_join_call, 0, arg) \
-    macro (KMP_fork_barrier, stats_flags_e::logEvent, arg)              \
-    macro (KMP_join_barrier, stats_flags_e::logEvent, arg)              \
-    macro (KMP_barrier, 0, arg)                   \
-    macro (KMP_end_split_barrier, 0, arg) \
-    macro (KMP_wait_sleep, 0, arg) \
-    macro (KMP_release, 0, arg)                   \
-    macro (KMP_hier_gather, 0, arg) \
-    macro (KMP_hier_release, 0, arg) \
-    macro (KMP_hyper_gather,  stats_flags_e::logEvent, arg) \
-    macro (KMP_hyper_release,  stats_flags_e::logEvent, arg) \
-    macro (KMP_linear_gather, 0, arg)                                   \
-    macro (KMP_linear_release, 0, arg)                                  \
-    macro (KMP_tree_gather, 0, arg)                                     \
-    macro (KMP_tree_release, 0, arg)                                    \
-    macro (USER_master_invoke, stats_flags_e::logEvent, arg) \
-    macro (USER_worker_invoke, stats_flags_e::logEvent, arg) \
-    macro (USER_resume, stats_flags_e::logEvent, arg) \
-    macro (USER_suspend, stats_flags_e::logEvent, arg) \
-    macro (USER_launch_thread_loop, stats_flags_e::logEvent, arg) \
-    macro (KMP_allocate_team, 0, arg) \
-    macro (KMP_setup_icv_copy, 0, arg) \
-    macro (USER_icv_copy, 0, arg) \
+    macro (TASK_execution, 0, arg)                                      \
+    macro (OMP_set_numthreads, stats_flags_e::noUnits, arg)             \
+    macro (OMP_PARALLEL_args,  stats_flags_e::noUnits, arg)             \
+    macro (OMP_single, 0, arg)                                          \
+    macro (OMP_master, 0, arg)                                          \
+    KMP_FOREACH_DEVELOPER_TIMER(macro, arg)                             \
     macro (LAST,0, arg)
 
 
-
-// OMP_PARALLEL_args      -- the number of arguments passed to a fork
-// FOR_static_iterations  -- Number of available parallel chunks of work in a static for
-// FOR_dynamic_iterations -- Number of available parallel chunks of work in a dynamic for
-//                           Both adjust for any chunking, so if there were an iteration count of 20 but a chunk size of 10, we'd record 2.
-// OMP_serial             -- thread zero time executing serial code
 // OMP_start_end          -- time from when OpenMP is initialized until the stats are printed at exit
+// OMP_serial             -- thread zero time executing serial code
 // OMP_work               -- elapsed time in code dispatched by a fork (measured in the thread)
 // Total_work             -- a synthesized statistic summarizing how much parallel work each thread executed.
 // OMP_barrier            -- time at "real" barriers
 // Total_barrier          -- a synthesized statistic summarizing how much time at real barriers in each thread
-// OMP_set_lock           -- time in lock setting
-// OMP_test_lock          -- time in testing a lock
-// LOCK_WAIT              -- time waiting for a lock
 // FOR_static_scheduling  -- time spent doing scheduling for a static "for"
 // FOR_dynamic_scheduling -- time spent doing scheduling for a dynamic "for"
-// KMP_wait_sleep         -- time in __kmp_wait_sleep
-// KMP_release            -- time in __kmp_release
+
+#if (KMP_DEVELOPER_STATS)
+// Timers which are of interest tio runtime library developers, not end users.
+// THese have to be explicitly enabled in addition to the other stats.
+
 // KMP_fork_barrier       -- time in __kmp_fork_barrier
 // KMP_join_barrier       -- time in __kmp_join_barrier
 // KMP_barrier            -- time in __kmp_barrier
 // KMP_end_split_barrier  -- time in __kmp_end_split_barrier
 // KMP_setup_icv_copy     -- time in __kmp_setup_icv_copy
 // KMP_icv_copy           -- start/stop timer for any ICV copying
 // KMP_linear_gather      -- time in __kmp_linear_barrier_gather
 // KMP_linear_release     -- time in __kmp_linear_barrier_release
 // KMP_tree_gather        -- time in __kmp_tree_barrier_gather
 // KMP_tree_release       -- time in __kmp_tree_barrier_release
 // KMP_hyper_gather       -- time in __kmp_hyper_barrier_gather
 // KMP_hyper_release      -- time in __kmp_hyper_barrier_release
+# define KMP_FOREACH_DEVELOPER_TIMER(macro, arg)                        \
+    macro (KMP_fork_call, 0, arg)                                       \
+    macro (KMP_join_call, 0, arg)                                       \
+    macro (KMP_fork_barrier, stats_flags_e::logEvent, arg)              \
+    macro (KMP_join_barrier, stats_flags_e::logEvent, arg)              \
+    macro (KMP_barrier, 0, arg)                                         \
+    macro (KMP_end_split_barrier, 0, arg)                               \
+    macro (KMP_hier_gather, 0, arg)                                     \
+    macro (KMP_hier_release, 0, arg)                                    \
+    macro (KMP_hyper_gather,  stats_flags_e::logEvent, arg)             \
+    macro (KMP_hyper_release,  stats_flags_e::logEvent, arg)            \
+    macro (KMP_linear_gather, 0, arg)                                   \
+    macro (KMP_linear_release, 0, arg)                                  \
+    macro (KMP_tree_gather, 0, arg)                                     \
+    macro (KMP_tree_release, 0, arg)                                    \
+    macro (USER_master_invoke, stats_flags_e::logEvent, arg)            \
+    macro (USER_worker_invoke, stats_flags_e::logEvent, arg)            \
+    macro (USER_resume, stats_flags_e::logEvent, arg)                   \
+    macro (USER_suspend, stats_flags_e::logEvent, arg)                  \
+    macro (USER_launch_thread_loop, stats_flags_e::logEvent, arg)       \
+    macro (KMP_allocate_team, 0, arg)                                   \
+    macro (KMP_setup_icv_copy, 0, arg)                                  \
+    macro (USER_icv_copy, 0, arg)                                       
+#else
+# define KMP_FOREACH_DEVELOPER_TIMER(macro, arg)
+#endif
 
 /*!
  * \brief Add new explicit timers under KMP_FOREACH_EXPLICIT_TIMER() macro.
  *
  * @param macro a user defined macro that takes three arguments - macro(TIMER_NAME, flags, arg)
  * @param arg a user defined argument to send to the user defined macro
  *
  * \warning YOU MUST HAVE THE SAME NAMED TIMER UNDER KMP_FOREACH_TIMER() OR ELSE BAD THINGS WILL HAPPEN!
  *
  * \details Explicit timers are ones where we need to allocate a timer itself (as well as the accumulated timing statistics).
  * We allocate these on a per-thread basis, and explicitly start and stop them.
  * Block timers just allocate the timer itself on the stack, and use the destructor to notice block exit; they don't
  * need to be defined here.
  * The name here should be the same as that of a timer above.
  *
  * @ingroup STATS_GATHERING
 */
-#define KMP_FOREACH_EXPLICIT_TIMER(macro, arg)  \
-    macro(OMP_serial, 0, arg)                   \
-    macro(OMP_start_end, 0, arg)                \
-    macro(USER_icv_copy, 0, arg) \
-    macro(USER_launch_thread_loop, stats_flags_e::logEvent, arg) \
+#define KMP_FOREACH_EXPLICIT_TIMER(macro, arg)          \
+    macro(OMP_serial, 0, arg)                           \
+    macro(OMP_start_end, 0, arg)                        \
+    macro(OMP_single, 0, arg)                           \
+    macro(OMP_master, 0, arg)                           \
+    KMP_FOREACH_EXPLICIT_DEVELOPER_TIMER(macro,arg)     \
     macro(LAST, 0, arg)
 
+#if (KMP_DEVELOPER_STATS)
+# define KMP_FOREACH_EXPLICIT_DEVELOPER_TIMER(macro, arg)               \
+    macro(USER_launch_thread_loop, stats_flags_e::logEvent, arg)
+#else
+# define KMP_FOREACH_EXPLICIT_DEVELOPER_TIMER(macro, arg)               
+#endif
+
 #define ENUMERATE(name,ignore,prefix) prefix##name,
 enum timer_e {
     KMP_FOREACH_TIMER(ENUMERATE, TIMER_)
 };
 
 enum explicit_timer_e {
     KMP_FOREACH_EXPLICIT_TIMER(ENUMERATE, EXPLICIT_TIMER_)
 };

  * \brief resets all stats (counters to 0, timers to 0 elapsed ticks)
  *
  * \details Reset all stats for all threads.
  *
  * @ingroup STATS_GATHERING
 */
 #define KMP_RESET_STATS()  __kmp_reset_stats()
 
+#if (KMP_DEVELOPER_STATS)
+# define KMP_TIME_DEVELOPER_BLOCK(n)             KMP_TIME_BLOCK(n)
+# define KMP_COUNT_DEVELOPER_VALUE(n,v)          KMP_COUNT_VALUE(n,v)
+# define KMP_COUNT_DEVELOPER_BLOCK(n)            KMP_COUNT_BLOCK(n)
+# define KMP_START_DEVELOPER_EXPLICIT_TIMER(n)   KMP_START_EXPLICIT_TIMER(n)
+# define KMP_STOP_DEVELOPER_EXPLICIT_TIMER(n)    KMP_STOP_EXPLICIT_TIMER(n)
+#else
+// Null definitions
+# define KMP_TIME_DEVELOPER_BLOCK(n)             ((void)0)
+# define KMP_COUNT_DEVELOPER_VALUE(n,v)          ((void)0)
+# define KMP_COUNT_DEVELOPER_BLOCK(n)            ((void)0)
+# define KMP_START_DEVELOPER_EXPLICIT_TIMER(n)   ((void)0)
+# define KMP_STOP_DEVELOPER_EXPLICIT_TIMER(n)    ((void)0)
+#endif
+
 #else // KMP_STATS_ENABLED
 
 // Null definitions
 #define KMP_TIME_BLOCK(n)             ((void)0)
 #define KMP_COUNT_VALUE(n,v)          ((void)0)
 #define KMP_COUNT_BLOCK(n)            ((void)0)
 #define KMP_START_EXPLICIT_TIMER(n)   ((void)0)
 #define KMP_STOP_EXPLICIT_TIMER(n)    ((void)0)
 
 #define KMP_OUTPUT_STATS(heading_string) ((void)0)
 #define KMP_RESET_STATS()  ((void)0)
 
+#define KMP_TIME_DEVELOPER_BLOCK(n)             ((void)0)
+#define KMP_COUNT_DEVELOPER_VALUE(n,v)          ((void)0)
+#define KMP_COUNT_DEVELOPER_BLOCK(n)            ((void)0)
+#define KMP_START_DEVELOPER_EXPLICIT_TIMER(n)   ((void)0)
+#define KMP_STOP_DEVELOPER_EXPLICIT_TIMER(n)    ((void)0)
 #endif  // KMP_STATS_ENABLED
 
 #endif // KMP_STATS_H

openmp/trunk/runtime/src/kmp_stats.cpp

for (it = __kmp_stats_list.begin(); it != __kmp_stats_list.end(); it++) {
             }
 
             statistic * threadStat = (*it)->getTimer(timer_e(s));
             allStats[s] += *threadStat;
         }
 
         // Special handling for synthesized statistics.
         // These just have to be coded specially here for now. 
-        // At present we only have one: the total parallel work done in each thread.
+        // At present we only have a few: 
+        // The total parallel work done in each thread.
         // The variance here makes it easy to see load imbalance over the whole program (though, of course,
         // it's possible to have a code with awful load balance in every parallel region but perfect load
         // balance oever the whole program.)
+        // The time spent in barriers in each thread.
         allStats[TIMER_Total_work].addSample ((*it)->getTimer(TIMER_OMP_work)->getTotal());
 
-        // Time waiting for work (synthesized)
-        if ((t != 0) || !timeStat::workerOnly(timer_e(TIMER_OMP_await_work)))
-            allStats[TIMER_Total_await_work].addSample ((*it)->getTimer(TIMER_OMP_await_work)->getTotal());
-
         // Time in explicit barriers.
         allStats[TIMER_Total_barrier].addSample ((*it)->getTimer(TIMER_OMP_barrier)->getTotal());
 
         for (int c = 0; c<COUNTER_LAST; c++) {
             if (counter::masterOnly(counter_e(c)) && t != 0)
                 continue;
             allCounters[c].addSample ((*it)->getCounter(counter_e(c))->getValue());
         }

openmp/trunk/runtime/src/kmp_tasking.c

 //
 //===----------------------------------------------------------------------===//
 
 
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
 #include "kmp_wait_release.h"
+#include "kmp_stats.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"
 #endif
 
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
#if OMP_40_ENABLED
     // TODO: cancel tasks if the parallel region has also been cancelled
     // TODO: check if this sequence can be hoisted above __kmp_task_start
     // if cancellation has been enabled for this run ...
     if (__kmp_omp_cancellation) {
         kmp_info_t *this_thr = __kmp_threads [ gtid ];
         kmp_team_t * this_team = this_thr->th.th_team;
         kmp_taskgroup_t * taskgroup = taskdata->td_taskgroup;
         if ((taskgroup && taskgroup->cancel_request) || (this_team->t.t_cancel_request == cancel_parallel)) {
+            KMP_COUNT_BLOCK(TASK_cancelled);
             // this task belongs to a task group and we need to cancel it
             discard = 1 /* true */;
         }
     }
 
     //
     // Invoke the task routine and pass in relevant data.
     // Thunks generated by gcc take a different argument list.
     //
     if (!discard) {
+        KMP_COUNT_BLOCK(TASK_executed);
+        KMP_TIME_BLOCK (TASK_execution);
 #endif // OMP_40_ENABLED
 #ifdef KMP_GOMP_COMPAT
         if (taskdata->td_flags.native) {
             ((void (*)(void *))(*(task->routine)))(task->shareds);
         }
         else
 #endif /* KMP_GOMP_COMPAT */
         {

 
 kmp_int32
 __kmpc_omp_taskyield( ident_t *loc_ref, kmp_int32 gtid, int end_part )
 {
     kmp_taskdata_t * taskdata;
     kmp_info_t * thread;
     int thread_finished = FALSE;
 
+    KMP_COUNT_BLOCK(OMP_TASKYIELD);
+
     KA_TRACE(10, ("__kmpc_omp_taskyield(enter): T#%d loc=%p end_part = %d\n",
                   gtid, loc_ref, end_part) );
 
     if ( __kmp_tasking_mode != tskm_immediate_exec && __kmp_init_parallel ) {
         // GEH TODO: shouldn't we have some sort of OMPRAP API calls here to mark begin wait?
 
         thread = __kmp_threads[ gtid ];
         taskdata = thread -> th.th_current_task;
if (*thread_finished) {
                       gtid, count + 1, task_team) );
 
         *thread_finished = FALSE;
     }
     TCW_4(victim_td -> td.td_deque_ntasks, TCR_4(victim_td -> td.td_deque_ntasks) - 1);
 
     __kmp_release_bootstrap_lock( & victim_td -> td.td_deque_lock );
 
+    KMP_COUNT_BLOCK(TASK_stolen);
     KA_TRACE(10, ("__kmp_steal_task(exit #3): T#%d stole task %p from T#%d: task_team=%p "
                   "ntasks=%d head=%u tail=%u\n",
                   gtid, taskdata, __kmp_gtid_from_thread( victim ), task_team,
                   victim_td->td.td_deque_ntasks, victim_td->td.td_deque_head,
                   victim_td->td.td_deque_tail) );
 
     task = KMP_TASKDATA_TO_TASK( taskdata );
     return task;

openmp/trunk/runtime/src/z_Linux_util.c

 }
 
 /* This routine puts the calling thread to sleep after setting the
  * sleep bit for the indicated flag variable to true.
  */
 template <class C>
 static inline void __kmp_suspend_template( int th_gtid, C *flag )
 {
-    KMP_TIME_BLOCK(USER_suspend);
+    KMP_TIME_DEVELOPER_BLOCK(USER_suspend);
     kmp_info_t *th = __kmp_threads[th_gtid];
     int status;
     typename C::flag_t old_spin;
 
     KF_TRACE( 30, ("__kmp_suspend_template: T#%d enter for flag = %p\n", th_gtid, flag->get() ) );
 
     __kmp_suspend_initialize_thread( th );
 

 
 /* This routine signals the thread specified by target_gtid to wake up
  * after setting the sleep bit indicated by the flag argument to FALSE.
  * The target thread must already have called __kmp_suspend_template()
  */
 template <class C>
 static inline void __kmp_resume_template( int target_gtid, C *flag )
 {
+    KMP_TIME_DEVELOPER_BLOCK(USER_resume);
     kmp_info_t *th = __kmp_threads[target_gtid];
     int status;
 
 #ifdef KMP_DEBUG
     int gtid = TCR_4(__kmp_init_gtid) ? __kmp_get_gtid() : -1;
 #endif
 
     KF_TRACE( 30, ( "__kmp_resume_template: T#%d wants to wakeup T#%d enter\n", gtid, target_gtid ) );

 }
 void __kmp_resume_oncore(int target_gtid, kmp_flag_oncore *flag) {
     __kmp_resume_template(target_gtid, flag);
 }
 
 void
 __kmp_resume_monitor()
 {
-    KMP_TIME_BLOCK(USER_resume);
     int status;
 #ifdef KMP_DEBUG
     int gtid = TCR_4(__kmp_init_gtid) ? __kmp_get_gtid() : -1;
     KF_TRACE( 30, ( "__kmp_resume_monitor: T#%d wants to wakeup T#%d enter\n",
                     gtid, KMP_GTID_MONITOR ) );
     KMP_DEBUG_ASSERT( gtid != KMP_GTID_MONITOR );
 #endif
     status = pthread_mutex_lock( &__kmp_wait_mx.m_mutex );