[OpenMP] Fix affinity API for KMP_AFFINITY=none|compact|scatter

[jlpeyton]

Summary

Currently, the affinity API reports garbage for the initial place list and any
thread's place lists when using KMP_AFFINITY=none|compact|scatter.
This patch does two things:

1. for KMP_AFFINITY=none, Creates a one entry table for the places, this way, the initial place list is just a single place with all the proc ids in it. We also set the initial place of any thread to 0 instead of KMP_PLACE_ALL so that the thread reports that single place (place 0) instead of garbage (-1) when using the affinity API.

2. When non-OMP_PROC_BIND affinity is used (including KMP_AFFINITY=compact|scatter), a thread's place list is populated correctly. We assume that each thread is assigned to a single place. This is implemented in two of the affinity API functions

[tlwilmar]

LGTM

[twoh]

Hello @jlpeyton @tlwilmar, is there a chance that this breaks runtime/test/ompt/misc/api_calls_from_other_thread.cpp test? ompt_get_num_places() is expected to return 0 from the test but with this patch it returns 1, and I think it is because kmp_affinity_num_masks is set to 1 from kmp_create_affinity_none_places().

[jlpeyton]

In D45527#1077680, @twoh wrote:

Hello @jlpeyton @tlwilmar, is there a chance that this breaks runtime/test/ompt/misc/api_calls_from_other_thread.cpp test? ompt_get_num_places() is expected to return 0 from the test but with this patch it returns 1, and I think it is because kmp_affinity_num_masks is set to 1 from kmp_create_affinity_none_places().

Yes, I will fix this. Thanks for pointing it out!

runtime/src/kmp.h

 
 extern kmp_nested_proc_bind_t __kmp_nested_proc_bind;
 
 #endif /* OMP_40_ENABLED */
 
 #if KMP_AFFINITY_SUPPORTED
 #define KMP_PLACE_ALL (-1)
 #define KMP_PLACE_UNDEFINED (-2)
+// Is KMP_AFFINITY is being used instead of OMP_PROC_BIND/OMP_PLACES?
+#define KMP_AFFINITY_NON_PROC_BIND                                             \
+  ((__kmp_nested_proc_bind.bind_types[0] == proc_bind_false ||                 \
+    __kmp_nested_proc_bind.bind_types[0] == proc_bind_intel) &&                \
+   (__kmp_affinity_num_masks > 0 || __kmp_affinity_type == affinity_balanced))
 #endif /* KMP_AFFINITY_SUPPORTED */
 
 extern int __kmp_affinity_num_places;
 
 #if OMP_40_ENABLED
 typedef enum kmp_cancel_kind_t {
   cancel_noreq = 0,
   cancel_parallel = 1,

runtime/src/kmp_affinity.cpp

 static AddrUnsPair *address2os = NULL;
 static int *procarr = NULL;
 static int __kmp_aff_depth = 0;
 
 #define KMP_EXIT_AFF_NONE                                                      \
   KMP_ASSERT(__kmp_affinity_type == affinity_none);                            \
   KMP_ASSERT(address2os == NULL);                                              \
   __kmp_apply_thread_places(NULL, 0);                                          \
+  __kmp_create_affinity_none_places();                                         \
   return;
 
+// Create a one element mask array (set of places) which only contains the
+// initial process's affinity mask
+static void __kmp_create_affinity_none_places() {
+  KMP_ASSERT(__kmp_affin_fullMask != NULL);
+  KMP_ASSERT(__kmp_affinity_type == affinity_none);
+  __kmp_affinity_num_masks = 1;
+  KMP_CPU_ALLOC_ARRAY(__kmp_affinity_masks, __kmp_affinity_num_masks);
+  kmp_affin_mask_t *dest = KMP_CPU_INDEX(__kmp_affinity_masks, 0);
+  KMP_CPU_COPY(dest, __kmp_affin_fullMask);
+}
+
 static int __kmp_affinity_cmp_Address_child_num(const void *a, const void *b) {
   const Address *aa = &(((const AddrUnsPair *)a)->first);
   const Address *bb = &(((const AddrUnsPair *)b)->first);
   unsigned depth = aa->depth;
   unsigned i;
   KMP_DEBUG_ASSERT(depth == bb->depth);
   KMP_DEBUG_ASSERT((unsigned)__kmp_affinity_compact <= depth);
   KMP_DEBUG_ASSERT(__kmp_affinity_compact >= 0);
#endif /* KMP_GROUP_AFFINITY */
 
   if (address2os == NULL) {
     if (KMP_AFFINITY_CAPABLE() &&
         (__kmp_affinity_verbose ||
          (__kmp_affinity_warnings && (__kmp_affinity_type != affinity_none)))) {
       KMP_WARNING(ErrorInitializeAffinity);
     }
     __kmp_affinity_type = affinity_none;
+    __kmp_create_affinity_none_places();
     KMP_AFFINITY_DISABLE();
     return;
   }
 
   if (__kmp_affinity_gran == affinity_gran_tile
 #if KMP_USE_HWLOC
       && __kmp_tile_depth == 0
 #endif
void __kmp_affinity_set_init_mask(int gtid, int isa_root) {
   // Copy the thread mask to the kmp_info_t strucuture. If
   // __kmp_affinity_type == affinity_none, copy the "full" mask, i.e. one that
   // has all of the OS proc ids set, or if __kmp_affinity_respect_mask is set,
   // then the full mask is the same as the mask of the initialization thread.
   kmp_affin_mask_t *mask;
   int i;
 
 #if OMP_40_ENABLED
-  if (__kmp_nested_proc_bind.bind_types[0] == proc_bind_intel)
+  if (KMP_AFFINITY_NON_PROC_BIND)
 #endif
   {
     if ((__kmp_affinity_type == affinity_none) ||
         (__kmp_affinity_type == affinity_balanced)) {
 #if KMP_GROUP_AFFINITY
       if (__kmp_num_proc_groups > 1) {
         return;
       }
 #endif
       KMP_ASSERT(__kmp_affin_fullMask != NULL);
-      i = KMP_PLACE_ALL;
+      i = 0;
       mask = __kmp_affin_fullMask;
     } else {
       KMP_DEBUG_ASSERT(__kmp_affinity_num_masks > 0);
       i = (gtid + __kmp_affinity_offset) % __kmp_affinity_num_masks;
       mask = KMP_CPU_INDEX(__kmp_affinity_masks, i);
     }
   }
 #if OMP_40_ENABLED

runtime/src/kmp_ftn_entry.h

 #else
   int gtid, num_places, first_place, last_place;
   kmp_info_t *thread;
   if (!TCR_4(__kmp_init_middle)) {
     __kmp_middle_initialize();
   }
   if (!KMP_AFFINITY_CAPABLE())
     return 0;
+  if (KMP_AFFINITY_NON_PROC_BIND) {
+    return 1;
+  }
   gtid = __kmp_entry_gtid();
   thread = __kmp_thread_from_gtid(gtid);
   first_place = thread->th.th_first_place;
   last_place = thread->th.th_last_place;
   if (first_place < 0 || last_place < 0)
     return 0;
   if (first_place <= last_place)
     num_places = last_place - first_place + 1;
#else
   kmp_info_t *thread;
   if (!TCR_4(__kmp_init_middle)) {
     __kmp_middle_initialize();
   }
   if (!KMP_AFFINITY_CAPABLE())
     return;
   gtid = __kmp_entry_gtid();
   thread = __kmp_thread_from_gtid(gtid);
+  if (KMP_AFFINITY_NON_PROC_BIND) {
+    place_nums[0] = thread->th.th_current_place;
+    return;
+  }
   first_place = thread->th.th_first_place;
   last_place = thread->th.th_last_place;
   if (first_place < 0 || last_place < 0)
     return;
   if (first_place <= last_place) {
     start = first_place;
     end = last_place;
   } else {

runtime/src/kmp_settings.cpp

#endif
     K_DIAG(1, ("__kmp_affinity_warnings     == %d\n", __kmp_affinity_warnings));
     K_DIAG(1, ("__kmp_affinity_respect_mask == %d\n",
                __kmp_affinity_respect_mask));
     K_DIAG(1, ("__kmp_affinity_gran         == %d\n", __kmp_affinity_gran));
 
     KMP_DEBUG_ASSERT(__kmp_affinity_type != affinity_default);
 #if OMP_40_ENABLED
     KMP_DEBUG_ASSERT(__kmp_nested_proc_bind.bind_types[0] != proc_bind_default);
+    K_DIAG(1, ("__kmp_nested_proc_bind.bind_types[0] == %d\n",
+               __kmp_nested_proc_bind.bind_types[0]));
 #endif
   }
 
 #endif /* KMP_AFFINITY_SUPPORTED */
 
   if (__kmp_version) {
     __kmp_print_version_1();
   }