[OpenMP] Enabling CPU affinity on Darwin platform proposal

[jdoerfert]

I can't test this but it looks reasonable, @protze.joachim what do you think?

[devnexen]

ping :-)

[protze.joachim]

As Johannes, I cannot test this. The code seems reasonable.
Please apply clang-format on the changes.

Something like:

git clang-format HEAD~

openmp/runtime/src/kmp_affinity.h

317

The formatting looks wrong here.

please apply git clang-format

[AndreyChurbanov]

openmp/runtime/src/kmp_affinity.h

313

IINM, if the def is true, then thread_policy_get will always return default policy, which is 0. Is it the intention here?

321

The affinity_tag is treated as kind of bit mask here. But actually the affinity_tag is just an ID which hints the system to keep closer threads with same tags, and keep spread threads with different tags.
Of cause it can be used as kind of mask anyway, if set appropriately in set_system_affinity.

And I am not sure the thread_policy_get can work with array of policies. From what I saw in public examples, it works with single policy, and cnt parameter is just the number of integers in the corresponding structure, not the size of array.

355

Same as for thread_policy_get, I think the thread_policy_set works with single policy, not with array of them. Thus the third parameter should be thread_affinity_policy_data_t*, not **. At least this is how public examples on thread_policy_set/get are written (though I can mistake here as I am not an expert in Darwin affinity).

openmp/runtime/src/z_Linux_util.cpp

130

If I read thread_policy.h correctly, the THREAD_AFFINITY_POLICY_COUNT is the number of integers in the thread_affinity_policy_data_t structure, which is 1. This does not relate with the size of CPU_SET.

301

The buf is array of size 1 byte here. Whereas the thread_policy_get writes 4 bytes (sizeof thread_affinity_policy_data_t structure) into buf.

308

Parameter to KMP_AFFINITY_ENABLE is the size of affinity mask. It can be 1 if __kmp_affin_mask_size is only used to indicate affinity capable, and the mask is not used as a bit mask. Or if there is single proc available on teh system that is unlikely nowadays.

openmp/runtime/src/kmp_affinity.h

KMPAffinity::Mask *index_mask_array(KMPAffinity::Mask *array,
                                       int index) override {
     Mask *hwloc_array = static_cast<Mask *>(array);
     return &(hwloc_array[index]);
   }
   api_type get_api_type() const override { return HWLOC; }
 };
 #endif /* KMP_USE_HWLOC */
 
-#if KMP_OS_LINUX || KMP_OS_FREEBSD
+#if KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_DARWIN
 #if KMP_OS_LINUX
 /* On some of the older OS's that we build on, these constants aren't present
    in <asm/unistd.h> #included from <sys.syscall.h>. They must be the same on
    all systems of the same arch where they are defined, and they cannot change.
    stone forever. */
 #include <sys/syscall.h>
 #if KMP_ARCH_X86 || KMP_ARCH_ARM
 #ifndef __NR_sched_setaffinity

 #elif __NR_sched_getaffinity != 5196
 #error Wrong code for getaffinity system call.
 #endif /* __NR_sched_getaffinity */
 #error Unknown or unsupported architecture
 #endif /* KMP_ARCH_* */
 #elif KMP_OS_FREEBSD
 #include <pthread.h>
 #include <pthread_np.h>
+#elif KMP_OS_DARWIN
+#include <mach/mach.h>
+#include <mach/thread_act.h>
+#include <mach/thread_policy.h>
 #endif
 class KMPNativeAffinity : public KMPAffinity {
   class Mask : public KMPAffinity::Mask {
     typedef unsigned char mask_t;
     static const int BITS_PER_MASK_T = sizeof(mask_t) * CHAR_BIT;
 
   public:
     mask_t *mask;
int get_system_affinity(bool abort_on_error) override {
                   "Illegal get affinity operation when not capable");
 #if KMP_OS_LINUX
       int retval =
           syscall(__NR_sched_getaffinity, 0, __kmp_affin_mask_size, mask);
 #elif KMP_OS_FREEBSD
       int r =
           pthread_getaffinity_np(pthread_self(), __kmp_affin_mask_size, reinterpret_cast<cpuset_t *>(mask));
       int retval = (r == 0 ? 0 : -1);
+#elif KMP_OS_DARWIN
+      boolean_t def = false;
+      int max_proc = __kmp_aux_get_affinity_max_proc();
+      mach_msg_type_number_t cnt = THREAD_AFFINITY_POLICY_COUNT;
+      thread_affinity_policy_data_t tmask[max_proc];
+      for (size_t i = 0; i < max_proc; i++) {
+          kern_return_t r = thread_policy_get(
+           mach_thread_self(), THREAD_AFFINITY_POLICY,
+           reinterpret_cast<thread_policy_t>(&tmask[i]), &cnt, &def);
+    if (r != KERN_SUCCESS)
+            return -1;
+          set(tmask[i].affinity_tag);
+      }
+      int retval = 0;
 #endif
       if (retval >= 0) {
         return 0;
       }
       int error = errno;
       if (abort_on_error) {
         __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
       }
       return error;
     }
     int set_system_affinity(bool abort_on_error) const override {
       KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
                   "Illegal get affinity operation when not capable");
 #if KMP_OS_LINUX
       int retval =
           syscall(__NR_sched_setaffinity, 0, __kmp_affin_mask_size, mask);
 #elif KMP_OS_FREEBSD
       int r =
           pthread_setaffinity_np(pthread_self(), __kmp_affin_mask_size, reinterpret_cast<cpuset_t *>(mask));
       int retval = (r == 0 ? 0 : -1);
+#elif KMP_OS_DARWIN
+      int max_proc = __kmp_aux_get_affinity_max_proc();
+      thread_affinity_policy_data_t tmask[max_proc];
+      int index = begin();
+
+      for (size_t i = 0; i < max_proc, index < end(); i ++) {
+        tmask[i].affinity_tag = index;
+  kern_return_t r = thread_policy_set(
+    mach_thread_self(), THREAD_AFFINITY_POLICY,
+    reinterpret_cast<thread_policy_t>(&tmask[i]), THREAD_AFFINITY_POLICY_COUNT);
+  if (r != KERN_SUCCESS)
+          return -1;
+        index = next(index);
+      }
+      int retval = 0;
 #endif
       if (retval >= 0) {
         return 0;
       }
       int error = errno;
       if (abort_on_error) {
         __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
       }
#endif
   }
   KMPAffinity::Mask *index_mask_array(KMPAffinity::Mask *array,
                                       int index) override {
     Mask *linux_array = static_cast<Mask *>(array);
     return &(linux_array[index]);
   }
   api_type get_api_type() const override { return NATIVE_OS; }
 };
-#endif /* KMP_OS_LINUX || KMP_OS_FREEBSD */
+#endif /* KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_DARWIN */
 
 #if KMP_OS_WINDOWS
 class KMPNativeAffinity : public KMPAffinity {
   class Mask : public KMPAffinity::Mask {
     typedef ULONG_PTR mask_t;
     static const int BITS_PER_MASK_T = sizeof(mask_t) * CHAR_BIT;
     mask_t *mask;
 

openmp/runtime/src/kmp_affinity.cpp

if (__kmp_affinity_verbose) {
       __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN, mask);
       KMP_INFORM(BoundToOSProcSet, "KMP_AFFINITY", (kmp_int32)getpid(),
                  __kmp_gettid(), tid, buf);
     }
     __kmp_set_system_affinity(mask, TRUE);
   }
 }
 
-#if KMP_OS_LINUX || KMP_OS_FREEBSD
+#if KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_DARWIN
 // We don't need this entry for Windows because
 // there is GetProcessAffinityMask() api
 //
 // The intended usage is indicated by these steps:
 // 1) The user gets the current affinity mask
 // 2) Then sets the affinity by calling this function
 // 3) Error check the return value
 // 4) Use non-OpenMP parallelization

openmp/runtime/src/kmp_os.h

 #define KMP_COMPILER_GCC 1
 #elif defined(_MSC_VER)
 #undef KMP_COMPILER_MSVC
 #define KMP_COMPILER_MSVC 1
 #else
 #error Unknown compiler
 #endif
 
-#if (KMP_OS_LINUX || KMP_OS_WINDOWS || KMP_OS_FREEBSD) && !KMP_OS_CNK
+#if (KMP_OS_LINUX || KMP_OS_WINDOWS || KMP_OS_FREEBSD || KMP_OS_DARWIN) && !KMP_OS_CNK
 #define KMP_AFFINITY_SUPPORTED 1
 #if KMP_OS_WINDOWS && KMP_ARCH_X86_64
 #define KMP_GROUP_AFFINITY 1
 #else
 #define KMP_GROUP_AFFINITY 0
 #endif
 #else
 #define KMP_AFFINITY_SUPPORTED 0

openmp/runtime/src/kmp_runtime.cpp

#endif
   team->t.t_control_stack_top = NULL;
 
   __kmp_reinitialize_team(team, new_icvs, loc);
 
   KMP_MB();
   KF_TRACE(10, ("__kmp_initialize_team: exit: team=%p\n", team));
 }
 
-#if (KMP_OS_LINUX || KMP_OS_FREEBSD) && KMP_AFFINITY_SUPPORTED
+#if (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_DARWIN) && KMP_AFFINITY_SUPPORTED
 /* Sets full mask for thread and returns old mask, no changes to structures. */
 static void
 __kmp_set_thread_affinity_mask_full_tmp(kmp_affin_mask_t *old_mask) {
   if (KMP_AFFINITY_CAPABLE()) {
     int status;
     if (old_mask != NULL) {
       status = __kmp_get_system_affinity(old_mask, TRUE);
       int error = errno;
#ifdef KMP_DEBUG
       }
 #endif
 
       KMP_CHECK_UPDATE(team->t.t_proc_bind, new_proc_bind);
 #if KMP_AFFINITY_SUPPORTED
       __kmp_partition_places(team);
 #endif
     } else { // team->t.t_nproc < new_nproc
-#if (KMP_OS_LINUX || KMP_OS_FREEBSD) && KMP_AFFINITY_SUPPORTED
+#if (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_DARWIN) && KMP_AFFINITY_SUPPORTED
       kmp_affin_mask_t *old_mask;
       if (KMP_AFFINITY_CAPABLE()) {
         KMP_CPU_ALLOC(old_mask);
       }
 #endif
 
       KA_TRACE(20,
                ("__kmp_allocate_team: increasing hot team thread count to %d\n",
#endif
         hot_teams[level].hot_team_nth = new_nproc; // adjust hot team max size
 #endif // KMP_NESTED_HOT_TEAMS
         if (team->t.t_max_nproc < new_nproc) {
           /* reallocate larger arrays */
           __kmp_reallocate_team_arrays(team, new_nproc);
           __kmp_reinitialize_team(team, new_icvs, NULL);
         }
 
-#if (KMP_OS_LINUX || KMP_OS_FREEBSD) && KMP_AFFINITY_SUPPORTED
+#if (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_DARWIN) && KMP_AFFINITY_SUPPORTED
         /* Temporarily set full mask for master thread before creation of
            workers. The reason is that workers inherit the affinity from master,
            so if a lot of workers are created on the single core quickly, they
            don't get a chance to set their own affinity for a long time. */
         __kmp_set_thread_affinity_mask_full_tmp(old_mask);
 #endif
 
         /* allocate new threads for the hot team */
#endif
                                KMP_BARRIER_PARENT_FLAG);
 #if USE_DEBUGGER
               balign[b].bb.b_worker_arrived = team->t.t_bar[b].b_team_arrived;
 #endif
             }
           }
         }
 
-#if (KMP_OS_LINUX || KMP_OS_FREEBSD) && KMP_AFFINITY_SUPPORTED
+#if (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_DARWIN) && KMP_AFFINITY_SUPPORTED
         if (KMP_AFFINITY_CAPABLE()) {
           /* Restore initial master thread's affinity mask */
           __kmp_set_system_affinity(old_mask, TRUE);
           KMP_CPU_FREE(old_mask);
         }
 #endif
 #if KMP_NESTED_HOT_TEAMS
       } // end of check of t_nproc vs. new_nproc vs. hot_team_nth

openmp/runtime/src/z_Linux_util.cpp

 #ifdef DEBUG_SUSPEND
 static void __kmp_print_cond(char *buffer, kmp_cond_align_t *cond) {
   KMP_SNPRINTF(buffer, 128, "(cond (lock (%ld, %d)), (descr (%p)))",
                cond->c_cond.__c_lock.__status, cond->c_cond.__c_lock.__spinlock,
                cond->c_cond.__c_waiting);
 }
 #endif
 
-#if ((KMP_OS_LINUX || KMP_OS_FREEBSD) && KMP_AFFINITY_SUPPORTED)
+#if ((KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_DARWIN) && KMP_AFFINITY_SUPPORTED)
 
 /* Affinity support */
 
 void __kmp_affinity_bind_thread(int which) {
   KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
               "Illegal set affinity operation when not capable");
 
   kmp_affin_mask_t *mask;

  * __kmp_affin_mask_size to the appropriate value (0 means not capable). */
 void __kmp_affinity_determine_capable(const char *env_var) {
 // Check and see if the OS supports thread affinity.
 
 #if KMP_OS_LINUX
 #define KMP_CPU_SET_SIZE_LIMIT (1024 * 1024)
 #elif KMP_OS_FREEBSD
 #define KMP_CPU_SET_SIZE_LIMIT (sizeof(cpuset_t))
+#elif KMP_OS_DARWIN
+#define KMP_CPU_SET_SIZE_LIMIT (sizeof(thread_affinity_policy_data_t))
 #endif
 
 
 #if KMP_OS_LINUX
   // If Linux* OS:
   // If the syscall fails or returns a suggestion for the size,
   // then we don't have to search for an appropriate size.
   int gCode;
#elif KMP_OS_FREEBSD
   if (gCode == 0) {
     KMP_AFFINITY_ENABLE(KMP_CPU_SET_SIZE_LIMIT);
     KA_TRACE(10, ("__kmp_affinity_determine_capable: "
                   "affinity supported (mask size %d)\n",
       (int)__kmp_affin_mask_size));
     KMP_INTERNAL_FREE(buf);
     return;
   }
+#elif KMP_OS_DARWIN
+  kern_return_t gCode;
+  unsigned char *buf;
+  boolean_t def = true;
+  mach_msg_type_number_t cnt = THREAD_AFFINITY_POLICY_COUNT;
+  buf = (unsigned char *)KMP_INTERNAL_MALLOC(KMP_CPU_SET_SIZE_LIMIT);
+  gCode = thread_policy_get(mach_thread_self(), THREAD_AFFINITY_POLICY,
+                            reinterpret_cast<thread_policy_t>(buf), &cnt, &def);
+  KA_TRACE(30, ("__kmp_affinity_determine_capable: "
+                "initial getaffinity call returned %d errno = %d\n",
+                gCode, errno));
+  if (gCode == KERN_SUCCESS) {
+    KMP_AFFINITY_ENABLE(KMP_CPU_SET_SIZE_LIMIT);
+    KA_TRACE(10, ("__kmp_affinity_determine_capable: "
+                  "affinity supported (mask size %d)\n"<
+      (int)__kmp_affin_mask_size));
+    KMP_INTERNAL_FREE(buf);
+    return;
+  }
 #endif
   // save uncaught error code
   // int error = errno;
   KMP_INTERNAL_FREE(buf);
   // restore uncaught error code, will be printed at the next KMP_WARNING below
   // errno = error;
 
   // Affinity is not supported