Simplify __kmp_expand_threads

[tlwilmar]

Summary

This change simplifies kmp_expand_threads to take a single argument. Previously it allowed two arguments and had logic to decide on different potential expansion sizes. However, no calls to kmp_expand_threads in the runtime make use of this extra logic. Thus the extra argument and logic is removed here.

[hbae]

LGTM.

runtime/src/kmp_runtime.cpp

 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);
 #endif
 
-static int __kmp_expand_threads(int nWish, int nNeed);
+static int __kmp_expand_threads(int nNeed);
 #if KMP_OS_WINDOWS
 static int __kmp_unregister_root_other_thread(int gtid);
 #endif
 static void __kmp_unregister_library(void); // called by __kmp_internal_end()
 static void __kmp_reap_thread(kmp_info_t *thread, int is_root);
 static kmp_info_t *__kmp_thread_pool_insert_pt = NULL;
 
 /* Calculate the identifier of the current thread */
#endif /* USE_LOAD_BALANCE */
   }
   if (__kmp_nth + new_nthreads -
           (root->r.r_active ? 1 : root->r.r_hot_team->t.t_nproc) >
       capacity) {
     // Expand the threads array.
     int slotsRequired = __kmp_nth + new_nthreads -
                         (root->r.r_active ? 1 : root->r.r_hot_team->t.t_nproc) -
                         capacity;
-    int slotsAdded = __kmp_expand_threads(slotsRequired, slotsRequired);
+    int slotsAdded = __kmp_expand_threads(slotsRequired);
     if (slotsAdded < slotsRequired) {
       // The threads array was not expanded enough.
       new_nthreads -= (slotsRequired - slotsAdded);
       KMP_ASSERT(new_nthreads >= 1);
 
       // If dyn-var is false, emit a 1-time warning.
       if (!get__dynamic_2(parent_team, master_tid) && (!__kmp_reserve_warn)) {
         __kmp_reserve_warn = 1;
/* This function attempts to create free entries in __kmp_threads and
 
    On all platforms, expansion is attempted on the arrays __kmp_threads_ and
    __kmp_root, with appropriate update to __kmp_threads_capacity. Array
    capacity is increased by doubling with clipping to __kmp_tp_capacity, if
    threadprivate cache array has been created. Synchronization with
    __kmpc_threadprivate_cached is done using __kmp_tp_cached_lock.
 
    After any dead root reclamation, if the clipping value allows array expansion
-   to result in the generation of a total of nWish free slots, the function does
-   that expansion. If not, but the clipping value allows array expansion to
-   result in the generation of a total of nNeed free slots, the function does
-   that expansion. Otherwise, nothing is done beyond the possible initial root
-   thread reclamation. However, if nNeed is zero, a best-effort attempt is made
-   to fulfil nWish as far as possible, i.e. the function will attempt to create
-   as many free slots as possible up to nWish.
+   to result in the generation of a total of nNeed free slots, the function does
+   that expansion. If not, nothing is done beyond the possible initial root
+   thread reclamation.
 
    If any argument is negative, the behavior is undefined. */
-static int __kmp_expand_threads(int nWish, int nNeed) {
+static int __kmp_expand_threads(int nNeed) {
   int added = 0;
   int old_tp_cached;
   int __kmp_actual_max_nth;
 
-  if (nNeed > nWish) /* normalize the arguments */
-    nWish = nNeed;
 #if KMP_OS_WINDOWS && !defined KMP_DYNAMIC_LIB
   /* only for Windows static library */
   /* reclaim array entries for root threads that are already dead */
   added = __kmp_reclaim_dead_roots();
 
   if (nNeed) {
     nNeed -= added;
     if (nNeed < 0)
       nNeed = 0;
   }
-  if (nWish) {
-    nWish -= added;
-    if (nWish < 0)
-      nWish = 0;
-  }
 #endif
-  if (nWish <= 0)
+  if (nNeed <= 0)
     return added;
 
   while (1) {
     int nTarget;
     int minimumRequiredCapacity;
     int newCapacity;
     kmp_info_t **newThreads;
     kmp_root_t **newRoot;
while (1) {
     // Anyway, that is the reason for moving the check to see if
     // __kmp_max_nth was exceeded into __kmp_reserve_threads()
     // instead of having it performed here. -BB
     old_tp_cached = __kmp_tp_cached;
     __kmp_actual_max_nth =
         old_tp_cached ? __kmp_tp_capacity : __kmp_sys_max_nth;
     KMP_DEBUG_ASSERT(__kmp_actual_max_nth >= __kmp_threads_capacity);
 
-    /* compute expansion headroom to check if we can expand and whether to aim
-       for nWish or nNeed */
-    nTarget = nWish;
-    if (__kmp_actual_max_nth - __kmp_threads_capacity < nTarget) {
-      /* can't fulfil nWish, so try nNeed */
-      if (nNeed) {
-        nTarget = nNeed;
-        if (__kmp_actual_max_nth - __kmp_threads_capacity < nTarget) {
-          /* possible expansion too small -- give up */
-          break;
-        }
-      } else {
-        /* best-effort */
-        nTarget = __kmp_actual_max_nth - __kmp_threads_capacity;
-        if (!nTarget) {
-          /* can expand at all -- give up */
-          break;
-        }
-      }
-    }
+    /* compute expansion headroom to check if we can expand */
     minimumRequiredCapacity = __kmp_threads_capacity + nTarget;
 
     newCapacity = __kmp_threads_capacity;
     do {
       newCapacity = newCapacity <= (__kmp_actual_max_nth >> 1)
                         ? (newCapacity << 1)
                         : __kmp_actual_max_nth;
     } while (newCapacity < minimumRequiredCapacity);
(2) we cannot detect initial thread reliably (the first thread which does
         serial initialization may be not a real initial thread).
   */
   capacity = __kmp_threads_capacity;
   if (!initial_thread && TCR_PTR(__kmp_threads[0]) == NULL) {
     --capacity;
   }
 
   /* see if there are too many threads */
-  if (__kmp_all_nth >= capacity && !__kmp_expand_threads(1, 1)) {
+  if (__kmp_all_nth >= capacity && !__kmp_expand_threads(1)) {
     if (__kmp_tp_cached) {
       __kmp_fatal(KMP_MSG(CantRegisterNewThread),
                   KMP_HNT(Set_ALL_THREADPRIVATE, __kmp_tp_capacity),
                   KMP_HNT(PossibleSystemLimitOnThreads), __kmp_msg_null);
     } else {
       __kmp_fatal(KMP_MSG(CantRegisterNewThread), KMP_HNT(SystemLimitOnThreads),
                   __kmp_msg_null);
     }