Fix for OMP_PROC_BIND=spread strategy

[tlwilmar]

Summary

The OMP_PROC_BIND=spread strategy fails to assign the master thread the correct place partition after the first parallel region. Other threads in the hot team will remember their place_partition, but the master's place partition is restored to what it was before entering the parallel region. So when the hot team is used for subsequent parallel regions, the master has lost this info. This fix calls __kmp_partition_places to update only the master thread's place partition in the spread case when there are no other changes to the hot team.

[AndreyChurbanov]

LGTM

openmp/trunk/runtime/src/kmp_runtime.c

 
 /* Forward declarations */
 
 void __kmp_cleanup( void );
 
 static void __kmp_initialize_info( kmp_info_t *, kmp_team_t *, int tid, int gtid );
 static void __kmp_initialize_team( kmp_team_t * team, int new_nproc, kmp_internal_control_t * new_icvs, ident_t * loc );
 #if OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
-static void __kmp_partition_places( kmp_team_t *team );
+static void __kmp_partition_places( kmp_team_t *team, int update_master_only=0 );
 #endif
 static void __kmp_do_serial_initialize( void );
 void __kmp_fork_barrier( int gtid, int tid );
 void __kmp_join_barrier( int gtid );
 void __kmp_setup_icv_copy( kmp_team_t *team, int new_nproc, kmp_internal_control_t * new_icvs, ident_t *loc );
 
 #ifdef USE_LOAD_BALANCE
 static int __kmp_load_balance_nproc( kmp_root_t * root, int set_nproc );

 
 //
 // __kmp_partition_places() is the heart of the OpenMP 4.0 affinity mechanism.
 // It calculats the worker + master thread's partition based upon the parent
 // thread's partition, and binds each worker to a thread in their partition.
 // The master thread's partition should already include its current binding.
 //
 static void
-__kmp_partition_places( kmp_team_t *team )
+__kmp_partition_places( kmp_team_t *team, int update_master_only )
 {
     //
     // Copy the master thread's place partion to the team struct
     //
     kmp_info_t *master_th = team->t.t_threads[0];
     KMP_DEBUG_ASSERT( master_th != NULL );
     kmp_proc_bind_t proc_bind = team->t.t_proc_bind;
     int first_place = master_th->th.th_first_place;
switch ( proc_bind ) {
         }
         break;
 
         case proc_bind_spread:
         {
             int f;
             int n_th = team->t.t_nproc;
             int n_places;
+            int thidx;
             if ( first_place <= last_place ) {
                 n_places = last_place - first_place + 1;
             }
             else {
                 n_places = __kmp_affinity_num_masks - first_place + last_place + 1;
             }
             if ( n_th <= n_places ) {
                 int place = masters_place;
                 int S = n_places/n_th;
                 int s_count, rem, gap, gap_ct;
                 rem = n_places - n_th*S;
                 gap = rem ? n_th/rem : 1;
                 gap_ct = gap;
-                for ( f = 0; f < n_th; f++ ) {
+                thidx = n_th;
+                if (update_master_only == 1)
+                    thidx = 1;
+                for ( f = 0; f < thidx; f++ ) {
                     kmp_info_t *th = team->t.t_threads[f];
                     KMP_DEBUG_ASSERT( th != NULL );
 
                     th->th.th_first_place = place;
                     th->th.th_new_place = place;
                     s_count = 1;
                     while (s_count < S) {
                         if ( place == last_place ) {
switch ( proc_bind ) {
             else {
                 int S, rem, gap, s_count;
                 S = n_th / n_places;
                 s_count = 0;
                 rem = n_th - ( S * n_places );
                 gap = rem > 0 ? n_places/rem : n_places;
                 int place = masters_place;
                 int gap_ct = gap;
-                for ( f = 0; f < n_th; f++ ) {
+                thidx = n_th;
+                if (update_master_only == 1)
+                    thidx = 1;
+                for ( f = 0; f < thidx; f++ ) {
                     kmp_info_t *th = team->t.t_threads[f];
                     KMP_DEBUG_ASSERT( th != NULL );
 
                     th->th.th_first_place = place;
                     th->th.th_last_place = place;
                     th->th.th_new_place = place;
                     s_count++;
 
#endif
             KF_TRACE( 10, ("__kmp_allocate_team2: T#%d, this_thread=%p team=%p\n",
                            0, team->t.t_threads[0], team ) );
             __kmp_push_current_task_to_thread( team->t.t_threads[ 0 ], team, 0 );
 
 #if OMP_40_ENABLED
 # if KMP_AFFINITY_SUPPORTED
             if ( ( team->t.t_size_changed == 0 )
               && ( team->t.t_proc_bind == new_proc_bind ) ) {
+                if (new_proc_bind == proc_bind_spread) {
+                    __kmp_partition_places(team, 1); // add flag to update only master for spread
+                }
                 KA_TRACE( 200, ("__kmp_allocate_team: reusing hot team #%d bindings: proc_bind = %d, partition = [%d,%d]\n",
                   team->t.t_id, new_proc_bind, team->t.t_first_place,
                   team->t.t_last_place ) );
             }
             else {
                 KMP_CHECK_UPDATE(team->t.t_proc_bind, new_proc_bind);
                 __kmp_partition_places( team );
             }