Fixed nonmonotonic dynamic schedule for case when #threads > #chunks in a loop.

[AndreyChurbanov]

Summary

The nonmonotonic dynamic schedule is internally mapped to static_steal schedule.
When #threads > #chunks stealing is not possible (at most one chunk per thread), so
library mistakenly did fallback to static_balanced which does not honor chunk size.
This patch changes the fallback from static to dynamic_chunked.

[jdoerfert]

LGTM.

openmp/runtime/src/kmp_dispatch.cpp

389

Nit: no braces.

openmp/runtime/src/kmp_dispatch.cpp

if (nproc > 1 && ntc >= nproc) {
         // free memory in __kmp_dispatch_next when status==0.
         KMP_DEBUG_ASSERT(th->th.th_dispatch->th_steal_lock == NULL);
         th->th.th_dispatch->th_steal_lock =
             (kmp_lock_t *)__kmp_allocate(sizeof(kmp_lock_t));
         __kmp_init_lock(th->th.th_dispatch->th_steal_lock);
       }
       break;
     } else {
-      KD_TRACE(100, ("__kmp_dispatch_init_algorithm: T#%d falling-through to "
-                     "kmp_sch_static_balanced\n",
+      /* too few chunks: switching to kmp_sch_dynamic_chunked */
+      schedule = kmp_sch_dynamic_chunked;
+      KD_TRACE(100, ("__kmp_dispatch_init_algorithm: T#%d switching to "
+                     "kmp_sch_dynamic_chunked\n",
                       gtid));
-      schedule = kmp_sch_static_balanced;
-      /* too few iterations: fall-through to kmp_sch_static_balanced */
+      if (pr->u.p.parm1 <= 0)
+        pr->u.p.parm1 = KMP_DEFAULT_CHUNK;
+      break;
     } // if
-    /* FALL-THROUGH to static balanced */
-    KMP_FALLTHROUGH();
   } // case
 #endif
   case kmp_sch_static_balanced: {
     T init, limit;
 
     KD_TRACE(
         100,
         ("__kmp_dispatch_init_algorithm: T#%d kmp_sch_static_balanced case\n",

openmp/runtime/test/worksharing/for/omp_nonmonotonic_dynamic1.c

+// RUN: %libomp-compile
+// RUN: env OMP_SCHEDULE=nonmonotonic:dynamic,10 %libomp-run
+
+// The test checks iterations distribution for OMP 5.0 nonmonotonic OMP_SCHEDULE
+// case #threads > #chunks (fallback to monotonic dynamic)
+
+#include <stdio.h>
+#include <omp.h>
+
+#define ITERS 100
+#define CHUNK 10
+int err = 0;
+
+int main(int argc, char **argv) {
+  int i, ch, it[ITERS];
+  omp_set_num_threads(16); // #threads is bigger than #chunks
+#pragma omp parallel for schedule(runtime)
+  for (i = 0; i < ITERS; ++i) {
+    it[i] = omp_get_thread_num();
+  }
+  // check that each chunk executed by single thread
+  for (ch = 0; ch < ITERS/CHUNK; ++ch) {
+    int iter = ch * CHUNK;
+    int nt = it[iter]; // thread number
+    for (i = 1; i < CHUNK; ++i) {
+#if _DEBUG
+      printf("iter %d: (%d %d)\n", iter + i, nt, it[iter + i]);
+#endif
+      if (nt != it[iter + i]) {
+        err++;
+      }
+    }
+  }
+  if (err > 0) {
+    printf("Failed, err = %d\n", err);
+    return 1;
+  }
+  printf("Passed\n");
+  return 0;
+}