#3188 Test new privatisation validation

Author: sergisiso

examples/nemo/scripts/omp_cpu_trans.py

@@ -40,7 +40,7 @@
 import os
 from utils import (
     insert_explicit_loop_parallelism, normalise_loops, add_profiling,
-    enhance_tree_information, PARALLELISATION_ISSUES, PRIVATISATION_ISSUES,
+    enhance_tree_information, PARALLELISATION_ISSUES,
     NEMO_MODULES_TO_IMPORT)
 from psyclone.psyir.nodes import Routine
 from psyclone.transformations import OMPLoopTrans
@@ -112,7 +112,6 @@ def trans(psyir):
                     region_directive_trans=omp_parallel_trans,
                     loop_directive_trans=omp_loop_trans,
                     collapse=False,
-                    privatise_arrays=(not NEMOV4 and
-                                      psyir.name not in PRIVATISATION_ISSUES),
+                    privatise_arrays=not NEMOV4,
                     enable_reductions=CPU_REDUCTIONS,
             )

examples/nemo/scripts/omp_gpu_trans.py

@@ -41,7 +41,7 @@
 from utils import (
     add_profiling, inline_calls, insert_explicit_loop_parallelism,
     normalise_loops, enhance_tree_information, PARALLELISATION_ISSUES,
-    NEMO_MODULES_TO_IMPORT, PRIVATISATION_ISSUES)
+    NEMO_MODULES_TO_IMPORT)
 from psyclone.psyir.nodes import Routine
 from psyclone.psyir.transformations import (
     OMPTargetTrans, OMPDeclareTargetTrans)
@@ -236,7 +236,7 @@ def trans(psyir):
                     region_directive_trans=omp_target_trans,
                     loop_directive_trans=omp_gpu_loop_trans,
                     collapse=True,
-                    privatise_arrays=(psyir.name not in PRIVATISATION_ISSUES),
+                    privatise_arrays=True,
                     asynchronous_parallelism=ASYNC_PARALLEL,
                     uniform_intrinsics_only=REPRODUCIBLE,
                     enable_reductions=not REPRODUCIBLE
@@ -252,7 +252,7 @@ def trans(psyir):
             insert_explicit_loop_parallelism(
                     subroutine,
                     loop_directive_trans=omp_cpu_loop_trans,
-                    privatise_arrays=(psyir.name not in PRIVATISATION_ISSUES),
+                    privatise_arrays=True,
                     asynchronous_parallelism=ASYNC_PARALLEL
             )
 

examples/nemo/scripts/utils.py

@@ -180,10 +180,6 @@
     "traqsr.f90",
 ]
 
-PRIVATISATION_ISSUES = [
-    "ldftra.f90",  # Wrong runtime results
-]
-
 
 def _it_should_be(symbol, of_type, instance):
     ''' Make sure that symbol has the datatype as provided.

src/psyclone/psyir/nodes/reference.py

@@ -300,6 +300,14 @@ def escapes_scope(
 
         # Check if this instance is in the provided scope
         if not self.is_descendant_of(scope):
+            # If the next_access is an array access we consider that it
+            # has escaped the escope, because even if it is a write, it
+            # can be to a subset of the indices. The rests will still
+            # need the previous values.
+            # pylint: disable=import-outside-toplevel
+            from psyclone.psyir.nodes.array_mixin import ArrayMixin
+            if isinstance(self, ArrayMixin):
+                return True
             # If following the recursive calls through next_accesses()
             # it reaches a point outside the scope, return True (
             # it has escaped the scope), unless this is a write-only

src/psyclone/psyir/transformations/parallel_loop_trans.py

@@ -49,9 +49,10 @@
 from psyclone.domain.common.psylayer import PSyLoop
 from psyclone.psyir import nodes
 from psyclone.psyir.nodes import (
-        Call, Loop, Reference, Routine,
+        Call, Loop, Reference, Routine, Assignment, IfBlock,
         BinaryOperation, IntrinsicCall
 )
+from psyclone.psyir.symbols import AutomaticInterface
 from psyclone.psyir.tools import (
         DependencyTools, DTCode, ReductionInferenceTool
 )
@@ -121,18 +122,57 @@ def _attempt_privatisation(loop, symbol_name, dry_run=False):
             # privatising these
             return False
 
+        # If it's not a local symbol, we cannot guarantee its lifetime
+        if not isinstance(sym.interface, AutomaticInterface):
+            return False
+
         if sym in loop.explicitly_private_symbols:
             return True
 
-        # Check that the symbol is not referenced following this loop (before
-        # the loop is fine because we can use OpenMP/OpenACC first-private or
-        # Fortran do concurrent local_init())
-        refs_in_loop = filter(lambda x: x.symbol is sym, loop.walk(Reference))
-        last_access = list(refs_in_loop)[-1]
         loop.compute_cached_abs_positions()
+
+        # Get the last access
+        refs_in_loop = filter(lambda x: x.symbol is sym, loop.walk(Reference))
+        refs_in_loop = list(refs_in_loop)
+        last_access = refs_in_loop[-1]
+        # If it's an assignment the last access is the one in the lhs
+        if last_access.ancestor(Assignment):
+            lhs = last_access.ancestor(Assignment).lhs
+            if isinstance(lhs, Reference) and lhs.symbol is sym:
+                last_access = lhs
+        # If the value of the symbol is used after the loop, it cannot be
+        # private
         if last_access.escapes_scope(loop):
             return False
 
+        # Also prevent cases when the first access in the loop is a read that
+        # could come from the previous iteration
+        while True:
+            first_access = refs_in_loop[0]
+            # If it's an assignment the first access is the one in the rhs
+            if first_access.ancestor(Assignment):
+                rhs = first_access.ancestor(Assignment).rhs
+                refs = filter(lambda x: x.symbol is sym, rhs.walk(Reference))
+                refs = list(refs)
+                if refs:
+                    first_access = refs[0]
+            if first_access.is_read:
+                return False
+            # If it is inside a conditional, there may be more entry points for
+            # this symbol, so we look for the next 'fist_access'
+            inside_conditional = first_access.ancestor(IfBlock, limit=loop)
+            if first_access.ancestor(IfBlock, limit=loop):
+                following = inside_conditional.following_node()
+                if not following:
+                    break
+                # Skip al references in the condition that we already checked
+                refs_in_loop = list(filter(
+                    lambda x: x.abs_position > following.abs_position,
+                    refs_in_loop
+                ))
+            if not inside_conditional or not refs_in_loop:
+                break
+
         if not dry_run:
             loop.explicitly_private_symbols.add(sym)