[gomp4] Compiler side of the cancellation support

Hi!

This is the compiler side of the #pragma omp cancel and #pragma omp
cancellation point support.  On the library side what is needed is:
1) GOMP_cancellation_point now returns a bool (whether the relevant
   cancellation was observed)
2) GOMP_cancel now has two arguments instead of just one, and returns
   bool like GOMP_cancellation_point.  If the second argument is false,
   it acts just like GOMP_cancellation_point, if it is true, it cancels
   the given construct.  For both these calls the first argument is
   1 for parallel cancellation, 2 for loop cancellation, 4 for sections and
   8 for taskgroup cancellation.
3) GOMP_barrier_cancel which is like GOMP_barrier, but should check
   for pending parallel cancellation and if parallel is cancelled, should
   return true
4) GOMP_sections_end_cancel and GOMP_loop_end_cancel variants to the
   non-cancel libcalls for the cancellation checking implicit barriers

The still unsolved problems are that for firstprivate/lastprivate
for, copyin_ref we add an implicit barrier that isn't really in the standard
and similarly for #pragma omp single copyprivate we don't use one barrier
mandated by the standard, but actually two barriers.  Not sure what exactly
we want as the behavior for these.  As some subset of threads can be
canceled before reaching the unofficial barrier (say one with #pragma omp
cancel parallel before reaching the omp for or omp single copyprivate)
and some others with #pragma omp cancellation point parallel, while some
threads hit the unofficial barrier before the cancellation (and optionally
some afterwards), do we want in the library to just arrange for all barriers
to be awaken and not block until the final barrier at the end of parallel is
hit, and for the unofficial barriers just not to return anything, while
for the official barriers (*_cancel suffixed) return true to signal jump to
end of region with running dtors?

Or perhaps keep track on how many threads in parallel have already observed
the cancellation and wait on non-*_cancel barriers only for the rest of the
threads that haven't observed it yet, and only on the *_cancel barriers
observe it for all threads.

Another issue is what if the dtors executed on the way contain barriers,
but that is probably ruled out by the restriction that 
"A construct that may be subject to cancellation must not encounter an orphaned
cancellation point."

Queuing this patch until we have a library implementation.

2013-07-03  Jakub Jelinek  <jakub@redhat.com>

	* gimple-pretty-print.c (dump_gimple_omp_return): Print
	gimple_omp_return_lhs if non-NULL.
	* tree-ssa-alias.c (ref_maybe_used_by_call_p_1,
	call_may_clobber_ref_p_1): Handle BUILT_IN_GOMP_BARRIER_CANCEL,
	BUILT_IN_GOMP_LOOP_END_CANCEL, BUILT_IN_GOMP_SECTIONS_END_CANCEL.
	* gimple.h (gimple_omp_return_set_lhs, gimple_omp_return_lhs,
	gimple_omp_return_lhs_ptr): New inlines.
	* gimple.def (GIMPLE_OMP_RETURN): Use GSS_OMP_ATOMIC_STORE
	instead of GSS_BASE.
	* gimple.c (walk_gimple_op) <case GIMPLE_OMP_RETURN>: Walk lhs.
	* builtin-types.def (BT_FN_BOOL_INT, BT_FN_BOOL_INT_BOOL): New.
	* omp-builtins.def (BUILT_IN_GOMP_CANCELLATION_POINT): Use
	ATTR_NOTHROW_LEAF_LIST instead of ATTR_NULL.  Return type is now
	bool.
	(BUILT_IN_GOMP_CANCEL): Likewise.  Add second argument with bool type.
	(BUILT_IN_BARRIER_CANCEL, BUILT_IN_GOMP_LOOP_END_CANCEL,
	BUILT_IN_GOMP_SECTIONS_END_CANCEL): New builtins.
	* omp-low.c (struct omp_context): Add cancel_label and cancellable
	fields.
	(extract_omp_for_data): Set have_nowait even for simd implicitly.
	(check_omp_nesting_restrictions): Verify nesting restrictions for
	#pragma omp cancel and #pragma omp cancellation point.
	Set ctx->cancellable for regions that can be cancelled or also
	for any task region that contains #pragma omp cancellation point.
	(scan_omp_1_stmt): Check nesting restrictions even if ctx == NULL.
	(build_omp_barrier): Return gimple instead of tree, add lhs argument,
	if non-NULL, build GOMP_barrier_cancel builtin instead and set its 
	call lhs to lhs.
	(lower_rec_input_clauses): Adjust build_omp_barrier caller.
	(expand_omp_for_static_nochunk, expand_omp_for_static_chunk,
	expand_omp_single): Likewise.  If OMP_RETURN has lhs, pass it to
	build_omp_barrier.
	(expand_omp_for_generic): If OMP_RETURN has lhs, use
	GOMP_loop_end_cancel libcall instead of GOMP_loop_end and set its
	lhs from OMP_RETURN's lhs.
	(expand_omp_sections): If OMP_RETURN has lhs, use
	GOMP_sections_end_cancel libcall instead of GOMP_sections_end and set
	its lhs from OMP_RETURN's lhs.
	(maybe_add_implicit_barrier_cancel): New function.
	(lower_omp_sections): If ctx->cancellable, emit cancel_label before
	OMP_RETURN.  Call maybe_add_implicit_barrier_cancel.
	(lower_omp_for): Likewise.
	(lower_omp_single): Call maybe_add_implicit_barrier_cancel.
	(lower_omp_taskreg): If ctx->cancellable, emit cancel_label before
	OMP_RETURN.
	(lower_omp_1): If ctx->cancellable, create ctx->cancel_label.
	Adjust GOMP_barrier libcalls to GOMP_barrier_cancel plus conditional
	branch in cancellable regions, adjust GOMP_cancel and
	GOMP_cancellation_point in cancellable regions or remove
	GOMP_cancellation_point in non-cancellable regions.
c/
	* c-typeck.c (c_finish_omp_cancel): Pass two arguments to GOMP_cancel
	rather than just one, if no OMP_CLAUSE_IF, pass true, otherwise pass
	if clause argument.  Emit the call unconditionally.
cp/
	* semantics.c (finish_omp_cancel): Pass two arguments to GOMP_cancel
	rather than just one, if no OMP_CLAUSE_IF, pass true, otherwise pass
	if clause argument.  Emit the call unconditionally.
fortran/
	* types.def (BT_FN_BOOL_INT, BT_FN_BOOL_INT_BOOL): New.

	Jakub
extern "C" int omp_get_thread_num ();

struct S { S (); ~S (); };

__attribute__((noinline))
S::S ()
{
}

__attribute__((noinline))
S::~S ()
{
}

void
fn0 (void)
{
  for (int i = 0; i < 100000; i++)
    ;
}

void
fn1 (int *x)
{
  S s;
  #pragma omp parallel firstprivate(x) num_threads (32)
  {
    S a;
    if (x[omp_get_thread_num ()] > 2)
      {
	S b;
        #pragma omp cancel parallel if (x[omp_get_thread_num ()] > 3)
      }
    else if (x[omp_get_thread_num ()] == 2)
      {
	S c, d;
        #pragma omp cancellation point parallel
      }
    #pragma omp barrier
    fn0 ();
  }
  #pragma omp parallel firstprivate(x) num_threads (8)
  {
    S a;
    if (x[omp_get_thread_num ()] > 3)
      {
	S b;
        #pragma omp cancel parallel
      }
    #pragma omp for schedule(runtime)
    for (int i = 0; i < 100000; i++)
      ;
    fn0 ();
  }
  #pragma omp parallel firstprivate(x) num_threads (16)
  {
    S a;
    if (x[omp_get_thread_num ()] > 3)
      {
	S b;
        #pragma omp cancel parallel
      }
    #pragma omp sections
      {
	fn0 ();
	#pragma omp section
	fn0 ();
	#pragma omp section
	fn0 ();
      }
    fn0 ();
  }
  int v;
  #pragma omp parallel firstprivate(x) num_threads (32)
  {
    S a;
    int v;
    if (x[v = omp_get_thread_num ()] > 3)
      {
	S b;
        #pragma omp cancel parallel
      }
    #pragma omp single copyprivate (v)
      fn0 ();
    fn0 ();
  }
}

void
fn2 (bool x)
{
  S s;
  #pragma omp sections
  {
    {
      #pragma omp cancellation point sections
    }
    #pragma omp section
    {
      S a;
      #pragma omp cancel sections if (x)
    }
    #pragma omp section
    {
      S b;
    }
    #pragma omp section
    {
      #pragma omp cancellation point sections
    }
  }
}

int x;

void
fn3 (int *y)
{
  #pragma omp for firstprivate (x)
  for (int i = 0; i < 1024; i++)
    {
      x += y[i] > 10;
      if (x > 10)
	{
	  #pragma omp cancel for if (x > 12)
	}
      else if (x > 8)
	{
	  #pragma omp cancellation point for
	}
    }
}

void
fn4 (int *x)
{
  #pragma omp task
  {
    if (x[omp_get_thread_num ()] > 10)
      {
	#pragma omp cancel taskgroup if (x[omp_get_thread_num ()] > 12)
      }
  }
  #pragma omp task
  {
    if (x[omp_get_thread_num ()] > 5)
      {
	#pragma omp cancellation point taskgroup
      }
  }
}

[gomp4] Compiler side of the cancellation support

Commit Message

Comments

Patch