How to find out if inside an openMP parallel region?

c, c++, openmp

Solution

The OpenMP standard states that `omp_in_parallel()` returns true if and only if the enclosing `parallel` region is active. An active `parallel` region is defined to be one that is executed by a team consisting of more than one thread. In your case you have an inactive parallel region since there is one thread only. Thus `omp_in_parallel()` returns `false` and the `throw` is executed. It errs because the OpenMP standard restricts exceptions to the same parallel region and thread:

A `throw` executed inside a `parallel` region must cause execution to resume within the same `parallel` region, and the same thread that threw the exception must catch it.

This makes your code non-conformant since you let an exception pass unhandled through the parallel region. The same error is emitted by the Intel OpenMP run-time so it is not a GCC-specific behaviour.

What happens actually is that GCC transforms the OpenMP region by wrapping your code in a `try/catch` block with a catch-all exception filter:

#pragma omp parallel [child fn: main.omp_fn.0 (???)]
  {
    try
      {
        do_something ();
      }
    catch
      {
        <<<eh_filter (NULL)>>>
          {
            terminate ();
          }
      }
    #pragma omp return
  }

It is this catch-all exception filter that is responsibe for the termination message.

To resolve this the entire `try/catch` block should be inside the parallel region and not vice versa:

# pragma omp parallel
{
   try {
      do_something();
   } catch(int e) {
      std::cerr<<"error: '"<<e<<"'\n";  // never gets here
   }
}

(the additional block was added to make Intel C++ Compiler happy; it is not strictly necessary for GCC)

This outputs `error: '3'` as expected.

Edit: The funny thing is that your exception handler doesn't even make it into the final binary. Even given the default optimisation level of GCC (i.e. compiling with `g++ -fopenmp -o prog prog.cc`), the redundancy eliminator is able to detect that your exception handler would never be reached because of the implicit inner exception handler and thus your handler is removed. Then the compiler finds out that the implicit termination handler is also redundant, since there is already a top-level exception handler for the whole process that does the same (calls `terminate()`) and thus removes even the implicit one. The final code is so lean and mean - no exception handlers at all:

;; Function int main() (main, funcdef_no=970, decl_uid=20816, cgraph_uid=212)

int main() ()
{
  int e;
  int D.20855;
  struct basic_ostream & D.20854;
  struct basic_ostream & D.20853;
  void * D.20852;
  register int * D.20819;

<bb 2>:
  omp_set_num_threads (1);
  __builtin_GOMP_parallel_start (main._omp_fn.0, 0B, 0);
  main._omp_fn.0 (0B);
  __builtin_GOMP_parallel_end ();
  D.20855_1 = 0;
  // <------ See, ma', no exception handling at all :)

<L0>:
  return D.20855_1;

}

;; Function <built-in> (main._omp_fn.0, funcdef_no=976, decl_uid=20857, cgraph_uid=222)

<built-in> (void * .omp_data_i)
{
<bb 2>:
  do_something ();
  return;
  // <------ See, ma', they've nuked the implicit termination handler

}

One gets to love the `-fdump-tree-all` GCC option.

Edit: As to the question on how to fix `do_something()` - use `omp_get_level()` instead of `omp_in_parallel()`:

void do_something()
{
   if(omp_get_level() == 0)
     throw 3;
}

`omp_get_level()` returns the level of nesting of the `parallel` regions that enclose the call, no matter if they are active or not.

Problem

Original source