(Towards #2271, closes #2278, closes #2849) Generalise reference_accesses() and use to tidy KernelModuleInlineTrans.

src/psyclone/core/access_type.py

@@ -37,7 +37,6 @@
 
 '''This module implements the AccessType used throughout PSyclone.'''
 
-from __future__ import print_function, absolute_import
 from enum import Enum
 from psyclone.configuration import Config
 
@@ -55,36 +54,40 @@ class AccessType(Enum):
     # This is used internally to indicate unknown access type of
     # a variable, e.g. when a variable is passed to a subroutine
     # and the access type of this variable in the subroutine
-    # is unknown
+    # is unknown.
     UNKNOWN = 7
+    # A symbol representing a routine is called.
+    CALL = 8
 
     def __str__(self):
         '''Convert to a string representation, returning just the
-        enum (e.g. 'WRITE')..
-        :return: API name for this string.
-        :rtype: str
+        enum (e.g. 'WRITE').
         '''
         # pylint complains without str() that the return type is not a str
         return str(self.name)
 
-    def api_specific_name(self):
+    def api_specific_name(self) -> str:
         '''This convenience function returns the name of the type in the
-        current API. E.g. in a lfric API, WRITE --> "gh_write"
+        current API. E.g. in the lfric API, WRITE --> "gh_write". If no
+        mapping is available then the generic name is returned.
+
         :returns: The API specific name.
-        :rtype: str
         '''
         api_config = Config.get().api_conf()
         rev_access_mapping = api_config.get_reverse_access_mapping()
-        return rev_access_mapping[self]
+        return rev_access_mapping.get(self, str(self).lower())
 
     @staticmethod
-    def from_string(access_string):
+    def from_string(access_string: str):
         '''Convert a string (e.g. "read") into the corresponding
         AccessType enum value (AccessType.READ).
 
-        :param str access_string: Access type as string.
+        :param access_string: Access type as a string.
+
         :returns: Corresponding AccessType enum.
-        :Raises: ValueError if access_string is not a valid access type.
+        :rtype: :py:class:`psyclone.core.access_type.AccessType`
+
+        :raises: ValueError if access_string is not a valid access type.
         '''
         for access in AccessType:
             if access.name == access_string.upper():

src/psyclone/core/single_variable_access_info.py

@@ -208,6 +208,14 @@ def var_name(self):
         '''
         return str(self._signature)
 
+    def is_called(self) -> bool:
+        '''
+        :returns: whether or not any accesses of this variable
+                  represent a call.
+        '''
+        return any(info.access_type == AccessType.CALL for
+                   info in self._accesses)
+
     def is_written(self):
         ''':returns: True if this variable is written (at least once).
         :rtype: bool
@@ -226,21 +234,21 @@ def is_written_first(self):
         return len(self._accesses) > 0 and \
             (self._accesses[0].access_type == AccessType.WRITE)
 
-    def is_read_only(self):
+    def is_read_only(self) -> bool:
         '''Checks if this variable is always read, and never
         written.
 
         :returns: True if this variable is read only.
-        :rtype: bool
         '''
         return all(access_info.access_type == AccessType.READ
                    for access_info in self._accesses)
 
-    def is_read(self):
-        ''':returns: True if this variable is read (at least once).
-        :rtype: bool
+    def is_read(self) -> bool:
+        '''
+        :returns: True if this variable is read (at least once).
         '''
-        return any(access_info.access_type in AccessType.all_read_accesses()
+        read_accesses = AccessType.all_read_accesses()
+        return any(access_info.access_type in read_accesses
                    for access_info in self._accesses)
 
     def has_read_write(self):

src/psyclone/core/variables_access_info.py

@@ -319,6 +319,14 @@ def merge(self, other_access_info):
         # locations just merged in
         self._location = self._location + max_new_location
 
+    def is_called(self, signature: Signature) -> bool:
+        '''
+        :param signature: signature of the variable.
+
+        :returns: True if the specified variable is called at least once.
+        '''
+        return self[signature].is_called()
+
     def is_written(self, signature):
         '''Checks if the specified variable signature is at least
         written once.
@@ -336,15 +344,14 @@ def is_written(self, signature):
         var_access_info = self[signature]
         return var_access_info.is_written()
 
-    def is_read(self, signature):
+    def is_read(self, signature) -> bool:
         '''Checks if the specified variable signature is at least read once.
 
         :param signature: signature of the variable
         :type signature: :py:class:`psyclone.core.Signature`
 
-        :returns: True if the specified variable name is read (at least \
+        :returns: True if the specified variable name is read (at least
             once).
-        :rtype: bool
 
         :raises: KeyError if the signature cannot be found.'''
 

src/psyclone/domain/common/transformations/kernel_module_inline_trans.py

@@ -43,13 +43,13 @@
 
 '''
 
-
+from psyclone.core import VariablesAccessInfo
 from psyclone.errors import InternalError
 from psyclone.psyGen import Transformation, CodedKern
 from psyclone.psyir.transformations import TransformationError
 from psyclone.psyir.symbols import (
     ContainerSymbol, DataSymbol, DataTypeSymbol, DefaultModuleInterface,
-    IntrinsicSymbol, RoutineSymbol, Symbol)
+    RoutineSymbol, Symbol)
 from psyclone.psyir.nodes import (
     Container, Reference, Routine, ScopingNode,
     Literal, CodeBlock, Call, IntrinsicCall)
@@ -156,41 +156,20 @@ def validate(self, node, options=None):
         # We do not support kernels that use symbols representing data
         # declared in their own parent module (we would need to new imports
         # from this module for those, and we don't do this yet).
-        # These can only be found in References and CodeBlocks.
-        for var in kernel_schedule.walk(Reference):
-            symbol = var.symbol
-            if isinstance(symbol, IntrinsicSymbol):
-                continue
-            if not symbol.is_import:
-                if not var.scope.symbol_table.lookup(
-                        symbol.name, scope_limit=kernel_schedule,
-                        otherwise=False):
-                    raise TransformationError(
-                        f"{kern_or_call} '{kname}' contains accesses to "
-                        f"'{symbol.name}' which is declared in the same "
-                        f"module scope. Cannot inline such a {kern_or_call}.")
-        for block in kernel_schedule.walk(CodeBlock):
-            for name in block.get_symbol_names():
-                # Is this quantity declared within the kernel?
-                sym = block.scope.symbol_table.lookup(
-                    name, scope_limit=kernel_schedule, otherwise=None)
-                if not sym:
-                    # It isn't declared in the kernel.
-                    # Can we find the corresponding symbol at all?
-                    sym = block.scope.symbol_table.lookup(name, otherwise=None)
-                    if not sym:
-                        raise TransformationError(
-                            f"{kern_or_call} '{kname}' contains accesses to "
-                            f"'{name}' in a CodeBlock but the origin of this "
-                            f"symbol is unknown.")
-                    # We found it in an outer scope - is it from an import or a
-                    # declaration?
-                    if not sym.is_import:
-                        raise TransformationError(
-                            f"{kern_or_call} '{kname}' contains accesses to "
-                            f"'{name}' in a CodeBlock that is declared in the "
-                            f"same module scope. Cannot inline such a "
-                            f"{kern_or_call}.")
+        vai = VariablesAccessInfo(kernel_schedule)
+        table = kernel_schedule.symbol_table
+        for sig in vai.all_signatures:
+            symbol = table.lookup(sig.var_name, otherwise=None)
+            if not symbol:
+                raise TransformationError(
+                    f"{kern_or_call} '{kname}' contains accesses to "
+                    f"'{sig.var_name}' but the origin of this symbol is "
+                    f"unknown.")
+            if not symbol.is_import and symbol.name not in table:
+                raise TransformationError(
+                    f"{kern_or_call} '{kname}' contains accesses to "
+                    f"'{symbol.name}' which is declared in the same "
+                    f"module scope. Cannot inline such a {kern_or_call}.")
 
         # We can't transform subroutines that shadow top-level symbol module
         # names, because we won't be able to bring this into the subroutine

src/psyclone/domain/lfric/lfric_extract_driver_creator.py

@@ -574,6 +574,11 @@ def _sym_is_field(sym):
         read_var = f"{psy_data.name}%ReadVariable"
         mod_man = ModuleManager.get()
 
+        # Construct a set of the names of all LFRic kind parameters.
+        const = LFRicConstants()
+        all_kind_names = set(
+            [val["kind"] for val in const.DATA_TYPE_MAP.values()])
+
         # First handle variables that are read:
         # -------------------------------------
         for module_name, signature in read_write_info.read_list:
@@ -583,6 +588,11 @@ def _sym_is_field(sym):
             # variables have References, and will already have been declared
             # in the symbol table (in _add_all_kernel_symbols).
             sig_str = self._flatten_signature(signature)
+
+            # Work-around for the fact that we want to exclude kind parameters.
+            if sig_str in all_kind_names:
+                continue
+
             if module_name:
                 mod_info = mod_man.get_module_info(module_name)
                 orig_sym = mod_info.get_symbol(signature[0])
@@ -593,6 +603,10 @@ def _sym_is_field(sym):
             else:
                 orig_sym = original_symbol_table.lookup(signature[0])
 
+            if orig_sym and isinstance(orig_sym, DataTypeSymbol):
+                # We don't want symbols representing data types.
+                continue
+
             if orig_sym and orig_sym.is_array and _sym_is_field(orig_sym):
                 # This is a field vector, so add all individual fields
                 upper = int(orig_sym.datatype.shape[0].upper.value)

src/psyclone/gocean1p0.py

@@ -1221,13 +1221,6 @@ def reference_accesses(self, var_accesses):
         super().reference_accesses(var_accesses)
         var_accesses.next_location()
 
-    def local_vars(self):
-        '''Return a list of the variable (names) that are local to this loop
-        (and must therefore be e.g. threadprivate if doing OpenMP)
-
-        '''
-        return []
-
     @property
     def index_offset(self):
         ''' The grid index-offset convention that this kernel expects '''

src/psyclone/psyGen.py

@@ -1323,9 +1323,6 @@ def is_coloured(self):
     def iterates_over(self):
         return self._iterates_over
 
-    def local_vars(self):
-        raise NotImplementedError("Kern.local_vars should be implemented")
-
     def gen_code(self, parent):
         raise NotImplementedError("Kern.gen_code should be implemented")
 
@@ -1815,14 +1812,6 @@ def _validate_child(position, child):
         '''
         return position == 0 and isinstance(child, Schedule)
 
-    @abc.abstractmethod
-    def local_vars(self):
-        '''
-        :returns: list of the variable (names) that are local to this kernel \
-                  (and must therefore be e.g. threadprivate if doing OpenMP)
-        :rtype: list of str
-        '''
-
     def node_str(self, colour=True):
         ''' Returns the name of this node with (optional) control codes
         to generate coloured output in a terminal that supports it.
@@ -1867,12 +1856,6 @@ def load(self, call, arguments, parent=None):
         name = call.ktype.name
         super(BuiltIn, self).__init__(parent, call, name, arguments)
 
-    def local_vars(self):
-        '''Variables that are local to this built-in and therefore need to be
-        made private when parallelising using OpenMP or similar. By default
-        builtin's do not have any local variables so set to nothing'''
-        return []
-
 
 class Arguments():
     '''

src/psyclone/psyir/nodes/call.py

@@ -315,10 +315,14 @@ def reference_accesses(self, var_accesses):
             # We conservatively default to READWRITE otherwise (TODO #446).
             default_access = AccessType.READWRITE
 
-        # TODO #2271: This may skip references in inner expressions of
-        # structure calls, but to implement properly we new a new kind of
-        # AccessType that represents being called (USED but not READ, maybe
-        # the same that we need for INQUIRY type attributes?)
+        # The RoutineSymbol has a CALL access.
+        sig, indices_list = self.routine.get_signature_and_indices()
+        var_accesses.add_access(sig, AccessType.CALL, self.routine)
+        # Any symbols referenced in any index expressions are READ.
+        for indices in indices_list:
+            for idx in indices:
+                idx.reference_accesses(var_accesses)
+
         for arg in self.arguments:
             if isinstance(arg, Reference):
                 # This argument is pass-by-reference.
@@ -373,12 +377,13 @@ def is_elemental(self):
     @property
     def is_pure(self):
         '''
-        :returns: whether the routine being called is pure (guaranteed to \
-            return the same result when provided with the same argument \
+        :returns: whether the routine being called is pure (guaranteed to
+            return the same result when provided with the same argument
             values).  If this information is not known then it returns None.
         :rtype: NoneType | bool
         '''
-        if self.routine and self.routine.symbol:
+        if (self.routine and self.routine.symbol and
+                isinstance(self.routine.symbol, RoutineSymbol)):
             return self.routine.symbol.is_pure
         return None
 

src/psyclone/psyir/nodes/codeblock.py

@@ -41,6 +41,7 @@
 from enum import Enum
 from fparser.two import Fortran2003
 from fparser.two.utils import walk
+from psyclone.core import AccessType, Signature, VariablesAccessInfo
 from psyclone.psyir.nodes.statement import Statement
 from psyclone.psyir.nodes.datanode import DataNode
 
@@ -174,8 +175,28 @@ def get_symbol_names(self):
                                  Fortran2003.End_If_Stmt)):
                 # We don't want labels associated with loop or branch control.
                 result.append(node.string)
-
+        # Precision on literals requires special attention since they are just
+        # stored in the tree as str (fparser/#456).
+        for node in walk(parse_tree, (Fortran2003.Int_Literal_Constant,
+                                      Fortran2003.Real_Literal_Constant)):
+            if node.items[1]:
+                result.append(node.items[1])
         return result
 
+    def reference_accesses(self, var_accesses: VariablesAccessInfo):
+        '''
+        Get all variable access information. Since this is a CodeBlock we
+        only know the names of symbols accessed within it but not how they
+        are accessed. Therefore we err on the side of caution and mark
+        them all as READWRITE.
+
+        :param var_accesses: VariablesAccessInfo instance that stores the
+            information about variable accesses.
+
+        '''
+        for name in self.get_symbol_names():
+            var_accesses.add_access(Signature(name), AccessType.READWRITE,
+                                    self)
+
     def __str__(self):
         return f"CodeBlock[{len(self._fp2_nodes)} nodes]"

src/psyclone/psyir/nodes/directive.py

@@ -105,6 +105,10 @@ def create_data_movement_deep_copy_refs(self):
             node = vinfo.all_accesses[0].node
             sym = table.lookup(sig.var_name)
 
+            if var_info.is_called(sig):
+                # Ignore accesses that are calls.
+                continue
+
             if isinstance(sym.datatype, ScalarType):
                 # We ignore scalars as these are typically copied by value.
                 continue