[openmp] Fixed nonmonotonic schedule when #threads > #chunks in a loop.

      }

      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: {

// 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;

}