[26/40] openacc: Warn about "independent" "kernels" loops with data-dependences
Commit Message
This commit concerns loops in OpenACC "kernels" region that have been marked
up with an explicit "independent" clause by the user, but for which Graphite
found data dependences. A discussion on the private internal OpenACC mailing
list suggested that warning the user about the dependences woud be a more
acceptable solution than reverting the user's decision. This behavior is
implemented by the present commit.
gcc/ChangeLog:
* common.opt: Add flag Wopenacc-false-independent.
* omp-offload.c (oacc_loop_warn_if_false_independent): New function.
(oacc_loop_fixed_partitions): Call from here.
---
gcc/common.opt | 5 +++++
gcc/omp-offload.c | 49 +++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 54 insertions(+)
--
2.33.0
-----------------
Siemens Electronic Design Automation GmbH; Anschrift: Arnulfstraße 201, 80634 München; Gesellschaft mit beschränkter Haftung; Geschäftsführer: Thomas Heurung, Frank Thürauf; Sitz der Gesellschaft: München; Registergericht München, HRB 106955
@@ -850,6 +850,11 @@ Wtsan
Common Var(warn_tsan) Init(1) Warning
Warn about unsupported features in ThreadSanitizer.
+Wopenacc-false-independent
+Common Var(warn_openacc_false_independent) Init(1) Warning
+Warn in case a loop in an OpenACC \"kernels\" region has an \"independent\"
+clause but analysis shows that it has loop-carried dependences.
+
Xassembler
Driver Separate
@@ -1900,6 +1900,51 @@ oacc_loop_transform_auto_into_independent (oacc_loop *loop)
return true;
}
+/* Emit a warning if LOOP has an "independent" clause but Graphite's
+ analysis shows that it has data dependences. Note that we respect
+ the user's explicit decision to parallelize the loop but we
+ nevertheless warn that this decision could be wrong. */
+
+static void
+oacc_loop_warn_if_false_independent (oacc_loop *loop)
+{
+ if (!optimize)
+ return;
+
+ if (loop->routine)
+ return;
+
+ /* TODO Warn about "auto" & "independent" in "parallel" regions? */
+ if (!oacc_parallel_kernels_graphite_fun_p ())
+ return;
+
+ if (!(loop->flags & OLF_INDEPENDENT))
+ return;
+
+ bool analyzed = false;
+ bool can_be_parallel = oacc_loop_can_be_parallel_p (loop, analyzed);
+ loop_p cfg_loop = oacc_loop_get_cfg_loop (loop);
+
+ if (cfg_loop && cfg_loop->inner && !analyzed)
+ {
+ if (dump_enabled_p ())
+ {
+ const dump_user_location_t loc
+ = dump_user_location_t::from_location_t (loop->loc);
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, loc,
+ "'independent' loop in 'kernels' region has not been "
+ "analyzed (cf. 'graphite' "
+ "dumps for more information).\n");
+ }
+ return;
+ }
+
+ if (!can_be_parallel)
+ warning_at (loop->loc, 0,
+ "loop has \"independent\" clause but data dependences were "
+ "found.");
+}
+
/* Walk the OpenACC loop hierarchy checking and assigning the
programmer-specified partitionings. OUTER_MASK is the partitioning
this loop is contained within. Return mask of partitioning
@@ -1951,6 +1996,10 @@ oacc_loop_fixed_partitions (oacc_loop *loop, unsigned outer_mask)
}
}
+ /* TODO Is this flag needed? Perhaps use -Wopenacc-parallelism? */
+ if (warn_openacc_false_independent)
+ oacc_loop_warn_if_false_independent (loop);
+
if (maybe_auto && (loop->flags & OLF_INDEPENDENT))
{
loop->flags |= OLF_AUTO;