Fix for https://bugs.llvm.org/show_bug.cgi?id=39970

[AndreyChurbanov]

Summary

Some tests require more than 1 thread to pass. The patch checks max threads, and if iti is 1 then sets number of threads to more than one.

Exceptions:
ompt/misc/api_calls_places.c - broke the standard requirement, fixed this;
worksharing/for/omp_doacross.c - could not reproduce the failure, increased the number of threads just in case.

[AndreyChurbanov]

Tom Stellard confirmed that this patch fixes all the issues reported. So, once this patch does not touch source code, I will commit it without formal review.

openmp/trunk/runtime/test/api/omp_in_parallel.c

int test_omp_in_parallel()
   return (!(serial) && isparallel);
 }
 
 int main()
 {
   int i;
   int num_failed=0;
 
+  // the test requires more than 1 thread to pass
+  omp_set_dynamic(0); // disable dynamic adjustment of threads
+  if (omp_get_max_threads() == 1)
+    omp_set_num_threads(2); // set 2 threads if no HW resources available
+
   for(i = 0; i < REPETITIONS; i++) {
     if(!test_omp_in_parallel()) {
       num_failed++;
     }
   }
   return num_failed;
 }

openmp/trunk/runtime/test/flush/omp_flush.c

int test_omp_flush()
   return ((result1 == result2) && (result2 == dummy) && (result2 == 3));
 }
 
 int main()
 {
   int i;
   int num_failed=0;
 
+  // the test requires more than 1 thread to pass
+  omp_set_dynamic(0); // disable dynamic adjustment of threads
+  if (omp_get_max_threads() == 1)
+    omp_set_num_threads(2); // set 2 threads if no HW resources available
+
   for (i = 0; i < REPETITIONS; i++) {
     if(!test_omp_flush()) {
       num_failed++;
     }
   }
   return num_failed;
 }

openmp/trunk/runtime/test/ompt/misc/api_calls_places.c

printf("%" PRIu64 ": omp_get_place_num()=%d\n",
            ompt_get_thread_data()->value, omp_get_place_num());
     printf("%" PRIu64 ": ompt_get_place_num()=%d\n",
            ompt_get_thread_data()->value, ompt_get_place_num());
 
     int omp_nums_size = omp_get_partition_num_places();
     int omp_nums[omp_nums_size];
     omp_get_partition_place_nums(omp_nums);
     print_list("omp_get_partition_place_nums", omp_nums_size, omp_nums);
-    int ompt_nums_size = ompt_get_partition_place_nums(0, NULL);
+    int ompt_nums_size = ompt_get_partition_place_nums(0, omp_nums);
     int ompt_nums[ompt_nums_size];
     ompt_get_partition_place_nums(ompt_nums_size, ompt_nums);
     print_list("ompt_get_partition_place_nums", ompt_nums_size, ompt_nums);
 
     printf("%" PRIu64 ": sched_getcpu()=%d\n", ompt_get_thread_data()->value,
            sched_getcpu());
     printf("%" PRIu64 ": ompt_get_proc_id()=%d\n",
            ompt_get_thread_data()->value, ompt_get_proc_id());

openmp/trunk/runtime/test/parallel/omp_nested.c

 // RUN: %libomp-compile-and-run
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 /*
  * Test if the compiler supports nested parallelism
  * By Chunhua Liao, University of Houston
  * Oct. 2005
  */
 int test_omp_nested()
 {
 #ifdef _OPENMP
   if (omp_get_max_threads() > 4)
     omp_set_num_threads(4);
+  if (omp_get_max_threads() < 2)
+    omp_set_num_threads(2);
 #endif
 
   int counter = 0;
 #ifdef _OPENMP
   omp_set_nested(1);
 #endif
 
   #pragma omp parallel shared(counter)

openmp/trunk/runtime/test/tasking/omp_task.c

int test_omp_task()
   return 0;
 } /* end of check_parallel_for_private */
 
 int main()
 {
   int i;
   int num_failed=0;
 
+  if (omp_get_max_threads() < 2)
+    omp_set_num_threads(8);
+
   for(i = 0; i < REPETITIONS; i++) {
     if(!test_omp_task()) {
       num_failed++;
     }
   }
   return num_failed;
 }

openmp/trunk/runtime/test/tasking/omp_taskyield.c

int test_omp_taskyield()
   return (count<NUM_TASKS);
 }
 
 int main()
 {
   int i;
   int num_failed=0;
 
+  if (omp_get_max_threads() < 2)
+    omp_set_num_threads(8);
+
   for(i = 0; i < REPETITIONS; i++) {
     if(!test_omp_taskyield()) {
       num_failed++;
     }
   }
   return num_failed;
 }

openmp/trunk/runtime/test/worksharing/for/kmp_sch_simd_runtime_api.c

run_loop(
     int loop_st,   // Loop stride.
     int lchunk
 ) {
   static int volatile loop_sync = 0;
   int lb;   // Chunk lower bound.
   int ub;   // Chunk upper bound.
   int st;   // Chunk stride.
   int rc;
+  int nthreads = omp_get_num_threads();
   int tid = omp_get_thread_num();
   int gtid = __kmpc_global_thread_num(&loc);
   int last;
   int tc = (loop_ub - loop_lb) / loop_st + 1;
   int ch;
   int no_chunk = 0;
   if (lchunk == 0) {
     no_chunk = 1;
#endif
                (int)st, (int)loop_st, chunk, ++err);
       cur = ( ub - lb ) / loop_st + 1;
       // Guided scheduling uses FP computations, so current chunk may
       // be a bit bigger (+1) than allowed maximum.
       if (!( cur <= max + 1))
         printf("Error with iter %d, %d, err %d\n", cur, max, ++err);
       // Update maximum for the next chunk.
       if (last) {
-        if (!no_chunk && cur > ch)
+        if (!no_chunk && cur > ch && nthreads > 1)
           printf("Error: too big last chunk %d (%d), tid %d, err %d\n",
                  (int)cur, ch, tid, ++err);
       } else {
         if (cur % ch)
           printf("Error with chunk %d, %d, ch %d, tid %d, err %d\n",
                  chunk, (int)cur, ch, tid, ++err);
       }
       if (cur < max)

openmp/trunk/runtime/test/worksharing/for/kmp_sch_simd_runtime_guided.c

run_loop(
     int loop_st,   // Loop stride.
     int lchunk
 ) {
   static int volatile loop_sync = 0;
   int lb;   // Chunk lower bound.
   int ub;   // Chunk upper bound.
   int st;   // Chunk stride.
   int rc;
+  int nthreads = omp_get_num_threads();
   int tid = omp_get_thread_num();
   int gtid = __kmpc_global_thread_num(&loc);
   int last;
   int tc = (loop_ub - loop_lb) / loop_st + 1;
   int ch;
   int no_chunk = 0;
   if (lchunk == 0) {
     no_chunk = 1;
#endif
       // Guided scheduling uses FP computations, so current chunk may
       // be a bit bigger (+1) than allowed maximum.
       if (!( cur <= max + 1))
         printf("Error with iter %d, %d, err %d\n", cur, max, ++err);
       // Update maximum for the next chunk.
       if (!last && cur % ch)
         printf("Error with chunk %d, %d, ch %d, tid %d, err %d\n",
                chunk, (int)cur, ch, tid, ++err);
-      if (last && !no_chunk && cur > ch)
+      if (last && !no_chunk && cur > ch && nthreads > 1)
         printf("Error: too big last chunk %d (%d), tid %d, err %d\n",
                (int)cur, ch, tid, ++err);
       if (cur < max)
         max = cur;
       last_ub = ub;
       undersized = (cur < ch);
 #if _DEBUG > 1
       if (last)

openmp/trunk/runtime/test/worksharing/for/kmp_sch_simd_runtime_static.c

run_loop(
     int loop_st,   // Loop stride.
     int lchunk
 ) {
   static int volatile loop_sync = 0;
   int lb;   // Chunk lower bound.
   int ub;   // Chunk upper bound.
   int st;   // Chunk stride.
   int rc;
+  int nthreads = omp_get_num_threads();
   int tid = omp_get_thread_num();
   int gtid = __kmpc_global_thread_num(&loc);
   int last;
   int tc = (loop_ub - loop_lb) / loop_st + 1;
   int ch;
   int no_chunk = 0;
   if (lchunk == 0) {
     no_chunk = 1;
#endif
                (int)st, (int)loop_st, chunk, ++err);
       cur = ( ub - lb ) / loop_st + 1;
       // Guided scheduling uses FP computations, so current chunk may
       // be a bit bigger (+1) than allowed maximum.
       if (!( cur <= max + 1))
         printf("Error with iter %d, %d, err %d\n", cur, max, ++err);
       // Update maximum for the next chunk.
       if (last) {
-        if (!no_chunk && cur > ch)
+        if (!no_chunk && cur > ch && nthreads > 1)
           printf("Error: too big last chunk %d (%d), tid %d, err %d\n",
                  (int)cur, ch, tid, ++err);
       } else {
         if (cur % ch)
           printf("Error with chunk %d, %d, ch %d, tid %d, err %d\n",
                  chunk, (int)cur, ch, tid, ++err);
       }
       if (cur < max)

openmp/trunk/runtime/test/worksharing/for/omp_doacross.c

int test_doacross() {
   int retval = (m[(N - 1) * N + N - 1] == 2 * (N - 1));
   free(m);
   return retval;
 }
 
 int main(int argc, char **argv) {
   int i;
   int num_failed = 0;
+  if (omp_get_max_threads() < 2)
+    omp_set_num_threads(4);
   for (i = 0; i < REPETITIONS; i++) {
     if (!test_doacross()) {
       num_failed++;
     }
   }
   return num_failed;
 }