Fixes for hierarchical barrier

[tlwilmar]

Summary

The problem was a hang when reducing a hot team's size and then increasing it again when KMP_HOT_TEAMS_MODE=1.
Threads that were removed but kept in the team for later re-use, and then added back later, were not properly set to wait on their own b_go flag. This was properly handled for the case when threads are returned to the pool, but not when kept in the team. However, this did not completely fix the hang.

The second problem was that a thread that was made active in the team again still thought it knew about its related leaf threads in the hierarchy, and tried to release them by setting it's own flag, as opposed to the leaves' flags. The leaves, however, were also recently made active again, and were thus waiting on their own b_go flags. The fix was easy: simply reset the known leaves to zero, via the "leaf_kids" field whenever threads in a team go inactive. The same problem would have existed for threads picked up from the pool, so this fix was made there as well.

[AndreyChurbanov]

LGTM

openmp/trunk/runtime/src/kmp_runtime.c

#endif // KMP_NESTED_HOT_TEAMS
                         // When decreasing team size, threads no longer in the team should unref task team.
                         team->t.t_threads[f]->th.th_task_team = NULL;
                     }
                     __kmp_free_thread( team->t.t_threads[ f ] );
                     team->t.t_threads[ f ] = NULL;
                 }
 #if KMP_NESTED_HOT_TEAMS
             } // (__kmp_hot_teams_mode == 0)
+            else {
+                // When keeping extra threads in team, switch threads to wait on own b_go flag
+                for (f=new_nproc; f<team->t.t_nproc; ++f) {
+                    KMP_DEBUG_ASSERT(team->t.t_threads[f]);
+                    kmp_balign_t *balign = team->t.t_threads[f]->th.th_bar;
+                    for (int b=0; b<bs_last_barrier; ++b) {
+                        if (balign[b].bb.wait_flag == KMP_BARRIER_PARENT_FLAG) {
+                            balign[b].bb.wait_flag = KMP_BARRIER_SWITCH_TO_OWN_FLAG;
+                        }
+                        KMP_CHECK_UPDATE(balign[b].bb.leaf_kids, 0);
+                    }
+                }
+            }
 #endif // KMP_NESTED_HOT_TEAMS
             team->t.t_nproc =  new_nproc;
             // TODO???: team->t.t_max_active_levels = new_max_active_levels;
             if (team->t.t_sched.r_sched_type != new_icvs->sched.r_sched_type ||
                 team->t.t_sched.chunk != new_icvs->sched.chunk)
                 team->t.t_sched = new_icvs->sched;
             __kmp_reinitialize_team( team, new_icvs, root->r.r_uber_thread->th.th_ident );
 
__kmp_free_thread( kmp_info_t *this_th )
 
     // When moving thread to pool, switch thread to wait on own b_go flag, and uninitialized (NULL team).
     int b;
     kmp_balign_t *balign = this_th->th.th_bar;
     for (b=0; b<bs_last_barrier; ++b) {
         if (balign[b].bb.wait_flag == KMP_BARRIER_PARENT_FLAG)
             balign[b].bb.wait_flag = KMP_BARRIER_SWITCH_TO_OWN_FLAG;
         balign[b].bb.team = NULL;
+        balign[b].bb.leaf_kids = 0;
     }
     this_th->th.th_task_state = 0;
 
     /* put thread back on the free pool */
     TCW_PTR(this_th->th.th_team, NULL);
     TCW_PTR(this_th->th.th_root, NULL);
     TCW_PTR(this_th->th.th_dispatch, NULL);               /* NOT NEEDED */