[OpenMP] Debug assert hit with nesting parallels

[mikaoP]

//  This is a simplification of task_teams_stress_test.cpp test
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <omp.h>

// The number of times to run each test
#define NTIMES 2

// Every thread creates a single "increment" task
void test_tasks() {
  for (int i = 0; i < 100; ++i)
  #pragma omp task
  {
  int tid = omp_get_thread_num();
  }
}

// Testing single level of parallelism with increment tasks
void test_base(int nthreads) {
#ifdef VERBOSE
#pragma omp master
  printf("    test_base(%d)\n", nthreads);
#endif
#pragma omp parallel num_threads(nthreads)
  { test_tasks(); }
}

// Testing nested parallel with increment tasks
// first = nthreads of outer parallel
// second = nthreads of nested parallel
void test_nest(int first, int second) {
#ifdef VERBOSE
#pragma omp master
  printf("   test_nest(%d, %d)\n", first, second);
#endif
#pragma omp parallel num_threads(first)
  {
  for (int i = 0; i < 100; ++i)
  #pragma omp task
  {
  int tid = omp_get_thread_num();
  }
    test_base(second);
  }
}

template <typename... Args>
void run_ntimes(int n, void (*func)(Args...), Args... args) {
  for (int i = 0; i < n; ++i) {
    func(args...);
  }
}

int main() {
  omp_set_max_active_levels(5);

  run_ntimes(NTIMES, test_nest, 4, 3);
  run_ntimes(NTIMES, test_nest, 2, 1);

  printf("PASS\n");
  return EXIT_SUCCESS;
}

Assertion failure at kmp_tasking.cpp(3238): victim_tid < task_team->tt.tt_nproc.
clang++ -fopenmp t1.cpp -o t1 && while taskset -c 0-1 env KMP_USE_YIELD=0 ./t1 || break; do date; done
Aparently it is necessary KMP_USE_YIELD=0. I've not managed how to reproduce it with 1 or 2. Also less cpus than threads is needed.

[mikaoP]

Reference commit of the assert 4ea2494 @jpeyton52

[llvmbot]

@llvm/issue-subscribers-openmp

Author: None (mikaoP)

```cpp // This is a simplification of task_teams_stress_test.cpp test #include <assert.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <omp.h>

// The number of times to run each test
#define NTIMES 2

// Every thread creates a single "increment" task
void test_tasks() {
for (int i = 0; i < 100; ++i)
#pragma omp task
{
int tid = omp_get_thread_num();
}
}

// Testing single level of parallelism with increment tasks
void test_base(int nthreads) {
#ifdef VERBOSE
#pragma omp master
printf(" test_base(%d)\n", nthreads);
#endif
#pragma omp parallel num_threads(nthreads)
{ test_tasks(); }
}

// Testing nested parallel with increment tasks
// first = nthreads of outer parallel
// second = nthreads of nested parallel
void test_nest(int first, int second) {
#ifdef VERBOSE
#pragma omp master
printf(" test_nest(%d, %d)\n", first, second);
#endif
#pragma omp parallel num_threads(first)
{
for (int i = 0; i < 100; ++i)
#pragma omp task
{
int tid = omp_get_thread_num();
}
test_base(second);
}
}

template <typename... Args>
void run_ntimes(int n, void (*func)(Args...), Args... args) {
for (int i = 0; i < n; ++i) {
func(args...);
}
}

int main() {
omp_set_max_active_levels(5);

run_ntimes(NTIMES, test_nest, 4, 3);
run_ntimes(NTIMES, test_nest, 2, 1);

printf("PASS\n");
return EXIT_SUCCESS;
}

`Assertion failure at kmp_tasking.cpp(3238): victim_tid < task_team->tt.tt_nproc.`
`clang++ -fopenmp t1.cpp -o t1 && while taskset -c 0-1 env KMP_USE_YIELD=0 ./t1 || break; do date; done`
Aparently it is necessary `KMP_USE_YIELD=0`. I've not managed how to reproduce it with 1 or 2. Also less cpus than threads is needed.
</details>

[mikaoP]

Reproduced too in the following example, based on omp_parallel_num_threads.c test. Basically I added tasks to enable tasking. Also without modifying the yield policy

#include <stdio.h>                                                                                                                                                                                                                              
#include <unistd.h>                                                                                                                                                                                                                             
#include "omp_testsuite.h"                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                
int test_omp_parallel_num_threads()                                                                                                                                                                                                             
{                                                                                                                                                                                                                                               
  int num_failed;                                                                                                                                                                                                                               
  int threads;                                                                                                                                                                                                                                  
  int nthreads;                                                                                                                                                                                                                                 
  int max_threads = 0;                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                
  num_failed = 0;                                                                                                                                                                                                                               
    #pragma omp task                                                                                                                                                                                                                            
    {}                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                
  /* first we check how many threads are available */                                                                                                                                                                                           
  #pragma omp parallel                                                                                                                                                                                                                          
  {                                                                                                                                                                                                                                             
    #pragma omp task                                                                                                                                                                                                                            
    {}                                                                                                                                                                                                                                          
    #pragma omp master                                                                                                                                                                                                                          
    max_threads = omp_get_num_threads ();                                                                                                                                                                                                       
  }                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                                
  /* we increase the number of threads from one to maximum:*/                                                                                                                                                                                   
  for(threads = 1; threads <= max_threads; threads++) {                                                                                                                                                                                         
    nthreads = 0;                                                                                                                                                                                                                               
    #pragma omp parallel reduction(+:num_failed) num_threads(threads)                                                                                                                                                                           
    {                                                                                                                                                                                                                                           
    #pragma omp task                                                                                                                                                                                                                            
    {}                                                                                                                                                                                                                                          
      num_failed = num_failed + !(threads == omp_get_num_threads());                                                                                                                                                                            
      #pragma omp atomic                                                                                                                                                                                                                        
      nthreads += 1;                                                                                                                                                                                                                            
    }                                                                                                                                                                                                                                           
    num_failed = num_failed + !(nthreads == threads);                                                                                                                                                                                           
  }                                                                                                                                                                                                                                             
  return (!num_failed);                                                                                                                                                                                                                         
}                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                
int main()                                                                                                                                                                                                                                      
{                                                                                                                                                                                                                                               
  int i;                                                                                                                                                                                                                                        
  int num_failed=0;                                                                                                                                                                                                                             
                                                                                                                                                                                                                                                
  for(i = 0; i < REPETITIONS; i++) {                                                                                                                                                                                                            
    if(!test_omp_parallel_num_threads()) {                                                                                                                                                                                                      
      num_failed++;                                                                                                                                                                                                                             
    }                                                                                                                                                                                                                                           
  }                                                                                                                                                                                                                                             
  return num_failed;                                                                                                                                                                                                                            
}

clang++ -fopenmp t1.c -o t1 && while ./t1 || break; do date; done

[jpeyton52]

Thanks, for reporting this. I just wanted to acknowledge that I've seen this and am investigating it now.