Fixes to wait-loop code

[jlpeyton]

Summary

1. Add get_ptr_type() method to all wait flag types.
2. Flag in sleep_loc may change type by the time the resume is called from __kmp_null_resume_wrapper. We use get_ptr_type to obtain the real type and compare it to the casted object received. If they don't match, we know the flag has changed (already resumed and replaced by another flag). If they match, it doesn't hurt to go ahead and resume it.

[tlwilmar]

LGTM

runtime/src/kmp_tasking.c

 static int  __kmp_realloc_task_threads_data( kmp_info_t *thread, kmp_task_team_t *task_team );
 
 #ifdef OMP_41_ENABLED
 static void __kmp_bottom_half_finish_proxy( kmp_int32 gtid, kmp_task_t * ptask );
 #endif
 
 static inline void __kmp_null_resume_wrapper(int gtid, volatile void *flag) {
     if (!flag) return;
+    // Attempt to wake up a thread: examine its type and call appropriate template
     switch (((kmp_flag_64 *)flag)->get_type()) {
     case flag32: __kmp_resume_32(gtid, NULL); break;
     case flag64: __kmp_resume_64(gtid, NULL); break;
     case flag_oncore: __kmp_resume_oncore(gtid, NULL); break;
     }
 }
 
 #ifdef BUILD_TIED_TASK_STACK

runtime/src/kmp_wait_release.h

int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin, int *thread_finished
                                       USE_ITT_BUILD_ARG(itt_sync_obj), is_constrained);
     }
     void wait(kmp_info_t *this_thr, int final_spin
               USE_ITT_BUILD_ARG(void * itt_sync_obj)) {
         __kmp_wait_template(this_thr, this, final_spin
                             USE_ITT_BUILD_ARG(itt_sync_obj));
     }
     void release() { __kmp_release_template(this); }
+    flag_type get_ptr_type() { return flag32; }
 };
 
 class kmp_flag_64 : public kmp_basic_flag<kmp_uint64> {
  public:
     kmp_flag_64(volatile kmp_uint64 *p) : kmp_basic_flag<kmp_uint64>(p) {}
     kmp_flag_64(volatile kmp_uint64 *p, kmp_info_t *thr) : kmp_basic_flag<kmp_uint64>(p, thr) {}
     kmp_flag_64(volatile kmp_uint64 *p, kmp_uint64 c) : kmp_basic_flag<kmp_uint64>(p, c) {}
     void suspend(int th_gtid) { __kmp_suspend_64(th_gtid, this); }
     void resume(int th_gtid) { __kmp_resume_64(th_gtid, this); }
     int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin, int *thread_finished
                       USE_ITT_BUILD_ARG(void * itt_sync_obj), kmp_int32 is_constrained) {
         return __kmp_execute_tasks_64(this_thr, gtid, this, final_spin, thread_finished
                                       USE_ITT_BUILD_ARG(itt_sync_obj), is_constrained);
     }
     void wait(kmp_info_t *this_thr, int final_spin
               USE_ITT_BUILD_ARG(void * itt_sync_obj)) {
         __kmp_wait_template(this_thr, this, final_spin
                             USE_ITT_BUILD_ARG(itt_sync_obj));
     }
     void release() { __kmp_release_template(this); }
+    flag_type get_ptr_type() { return flag64; }
 };
 
 // Hierarchical 64-bit on-core barrier instantiation
 class kmp_flag_oncore : public kmp_flag<kmp_uint64> {
     kmp_uint64 checker;
     kmp_info_t * waiting_threads[1];
     kmp_uint32 num_waiting_threads;
     kmp_uint32 offset;      /**< Portion of flag that is of interest for an operation. */
#endif
     void resume(int th_gtid) { __kmp_resume_oncore(th_gtid, this); }
     int execute_tasks(kmp_info_t *this_thr, kmp_int32 gtid, int final_spin, int *thread_finished
                       USE_ITT_BUILD_ARG(void * itt_sync_obj), kmp_int32 is_constrained) {
         return __kmp_execute_tasks_oncore(this_thr, gtid, this, final_spin, thread_finished
                                           USE_ITT_BUILD_ARG(itt_sync_obj), is_constrained);
     }
     kmp_uint8 *get_stolen() { return NULL; }
     enum barrier_type get_bt() { return bt; }
+    flag_type get_ptr_type() { return flag_oncore; }
 };
 
 
 /*!
 @}
 */
 
 #endif // KMP_WAIT_RELEASE_H

runtime/src/z_Linux_util.c

#endif
     KF_TRACE( 30, ( "__kmp_resume_template: T#%d wants to wakeup T#%d enter\n", gtid, target_gtid ) );
     KMP_DEBUG_ASSERT( gtid != target_gtid );
 
     __kmp_suspend_initialize_thread( th );
 
     status = pthread_mutex_lock( &th->th.th_suspend_mx.m_mutex );
     KMP_CHECK_SYSFAIL( "pthread_mutex_lock", status );
 
-    if (!flag) {
+    if (!flag) { // coming from __kmp_null_resume_wrapper
         flag = (C *)th->th.th_sleep_loc;
     }
 
-    if (!flag) {
+    // First, check if the flag is null or its type has changed. If so, someone else woke it up.
+    if (!flag || flag->get_type() != flag->get_ptr_type()) { // get_ptr_type simply shows what flag was cast to
         KF_TRACE( 5, ( "__kmp_resume_template: T#%d exiting, thread T#%d already awake: flag(%p)\n",
                        gtid, target_gtid, NULL ) );
         status = pthread_mutex_unlock( &th->th.th_suspend_mx.m_mutex );
         KMP_CHECK_SYSFAIL( "pthread_mutex_unlock", status );
         return;
     }
     else { // if multiple threads are sleeping, flag should be internally referring to a specific thread here
         typename C::flag_t old_spin = flag->unset_sleeping();

runtime/src/z_Windows_NT_util.c

#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 ) );
 
     __kmp_suspend_initialize_thread( th );
     __kmp_win32_mutex_lock( &th->th.th_suspend_mx );
 
-    if (!flag) {
+    if (!flag) { // coming from __kmp_null_resume_wrapper
         flag = (C *)th->th.th_sleep_loc;
     }
 
-    if (!flag) {
+    // First, check if the flag is null or its type has changed. If so, someone else woke it up.
+    if (!flag || flag->get_type() != flag->get_ptr_type()) { // get_ptr_type simply shows what flag was cast to
         KF_TRACE( 5, ( "__kmp_resume_template: T#%d exiting, thread T#%d already awake: flag's loc(%p)\n",
                        gtid, target_gtid, NULL ) );
         __kmp_win32_mutex_unlock( &th->th.th_suspend_mx );
         return;
     }
     else {
         typename C::flag_t old_spin = flag->unset_sleeping();
         if ( !flag->is_sleeping_val(old_spin) ) {