(closes #1010) Generate PSy-layers and Kernel Subs using PSyIR lowering (instead of gen_code/f2pygen)

doc/user_guide/psyke.rst

@@ -224,8 +224,8 @@ PSyclone modifies the Schedule of the selected ``invoke_0``:
   Schedule[invoke='invoke_0' dm=False]
       0: Loop[type='dofs',field_space='any_space_1',it_space='dofs',
               upper_bound='ndofs']
-          Literal[value:'NOT_INITIALISED']
-          Literal[value:'NOT_INITIALISED']
+          Reference[name:'loop0_start']
+          Reference[name:'loop0_stop']
           Literal[value:'1']
           Schedule[]
               0: BuiltIn setval_c(f5,0.0)

examples/lfric/README.md

@@ -245,14 +245,14 @@ Kernel call 'matrix_vector_code' was found in
 InvokeSchedule[invoke='invoke_0', dm=False]
     ...
     Loop[type='', field_space='any_space_1', it_space='cells', upper_bound='ncells']
-        Literal[value:'NOT_INITIALISED']
-        Literal[value:'NOT_INITIALISED']
+        Reference[name:'loop0_start']
+        Reference[name:'loop0_stop']
         Literal[value:'1']
         Schedule[]
             CodedKern matrix_vector_kernel_code(m_lumped,ones,mb) [module_inline=False]
     Loop[type='dofs', field_space='any_space_1', it_space='dofs', upper_bound='ndofs']
-        Literal[value:'NOT_INITIALISED']
-        Literal[value:'NOT_INITIALISED']
+        Reference[name:'loop1_start']
+        Reference[name:'loop1_stop']
         Literal[value:'1']
         Schedule[]
             BuiltIn x_divideby_y(self_mb_lumped_inv,ones,m_lumped)

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
 

src/psyclone/core/component_indices.py

@@ -36,8 +36,6 @@
 
 '''This module provides a class to manage indices in variable accesses.'''
 
-from __future__ import print_function, absolute_import
-
 
 from psyclone.errors import InternalError
 

src/psyclone/domain/lfric/arg_ordering.py

@@ -51,7 +51,7 @@
     MetadataToArgumentsRules)
 from psyclone.errors import GenerationError, InternalError
 from psyclone.psyir.nodes import ArrayReference, Reference
-from psyclone.psyir.symbols import ScalarType
+from psyclone.psyir.symbols import DataSymbol, ArrayType
 
 
 class ArgOrdering:
@@ -102,10 +102,11 @@ def _symtab(self):
         '''
         if self._forced_symtab:
             return self._forced_symtab
-        elif self._kern and self._kern.ancestor(psyGen.InvokeSchedule):
-            return self._kern.ancestor(psyGen.InvokeSchedule).symbol_table
-        else:
-            return LFRicSymbolTable()
+        if self._kern and self._kern.ancestor(psyGen.InvokeSchedule):
+            # _kern may be outdated, so go back up to the invoke first
+            current_invoke = self._kern.ancestor(psyGen.InvokeSchedule).invoke
+            return current_invoke.schedule.symbol_table
+        return LFRicSymbolTable()
 
     def psyir_append(self, node):
         '''Appends a PSyIR node to the PSyIR argument list.
@@ -197,13 +198,17 @@ def append_integer_reference(self, name, tag=None):
         :rtype: :py:class:`psyclone.psyir.symbols.Symbol`
 
         '''
+        # pylint: disable=import-outside-toplevel
+        from psyclone.domain.lfric import LFRicTypes
         if tag is None:
             tag = name
-        sym = self._symtab.find_or_create_integer_symbol(name, tag)
+        sym = self._symtab.find_or_create(
+                name, tag=tag, symbol_type=DataSymbol,
+                datatype=LFRicTypes("LFRicIntegerScalarDataType")())
         self.psyir_append(Reference(sym))
         return sym
 
-    def get_array_reference(self, array_name, indices, intrinsic_type,
+    def get_array_reference(self, array_name, indices, intrinsic_type=None,
                             tag=None, symbol=None):
         # pylint: disable=too-many-arguments
         '''This function creates an array reference. If there is no symbol
@@ -215,9 +220,10 @@ def get_array_reference(self, array_name, indices, intrinsic_type,
         :param indices: the indices to be used in the PSyIR reference. It \
             must either be ":", or a PSyIR node.
         :type indices: List[Union[str, py:class:`psyclone.psyir.nodes.Node`]]
-        :param intrinsic_type: the intrinsic type of the array.
+        :param intrinsic_type: the intrinsic type of the array. Defaults to
+            LFRicIntegerScalarDataType.
         :type intrinsic_type: \
-            :py:class:`psyclone.psyir.symbols.datatypes.ScalarType.Intrinsic`
+            Optional[:py:class:`psyclone.psyir.symbols.datatypes.ScalarType`]
         :param tag: optional tag for the symbol.
         :type tag: Optional[str]
         :param symbol: optional the symbol to use.
@@ -229,11 +235,17 @@ def get_array_reference(self, array_name, indices, intrinsic_type,
         '''
         if not tag:
             tag = array_name
+        if intrinsic_type is None:
+            # pylint: disable=import-outside-toplevel
+            from psyclone.domain.lfric import LFRicTypes
+            intrinsic_type = LFRicTypes("LFRicIntegerScalarDataType")()
+
         if not symbol:
-            symbol = self._symtab.find_or_create_array(array_name,
-                                                       len(indices),
-                                                       intrinsic_type,
-                                                       tag)
+            symbol = self._symtab.find_or_create(
+                array_name, tag=tag, symbol_type=DataSymbol,
+                datatype=ArrayType(
+                    intrinsic_type,
+                    [ArrayType.Extent.DEFERRED for _ in indices]))
         else:
             if symbol.name != array_name:
                 raise InternalError(f"Specified symbol '{symbol.name}' has a "
@@ -248,7 +260,7 @@ def get_array_reference(self, array_name, indices, intrinsic_type,
             ref = ArrayReference.create(symbol, indices)
         return ref
 
-    def append_array_reference(self, array_name, indices, intrinsic_type,
+    def append_array_reference(self, array_name, indices, intrinsic_type=None,
                                tag=None, symbol=None):
         # pylint: disable=too-many-arguments
         '''This function adds an array reference. If there is no symbol with
@@ -263,7 +275,7 @@ def append_array_reference(self, array_name, indices, intrinsic_type,
         :type indices: List[Union[str, py:class:`psyclone.psyir.nodes.Node`]]
         :param intrinsic_type: the intrinsic type of the array.
         :type intrinsic_type: \
-            :py:class:`psyclone.psyir.symbols.datatypes.ScalarType.Intrinsic`
+            Optional[:py:class:`psyclone.psyir.symbols.datatypes.ScalarType`]
         :param tag: optional tag for the symbol.
         :type tag: Optional[str]
         :param symbol: optional the symbol to use.
@@ -912,8 +924,7 @@ def banded_dofmap(self, function_space, var_accesses=None):
         # to the argument list as they are mandatory for every function
         # space that appears in the meta-data.
         sym = self.append_array_reference(
-            function_space.cbanded_map_name, indices=[":", ":"],
-            intrinsic_type=ScalarType.Intrinsic.INTEGER)
+            function_space.cbanded_map_name, indices=[":", ":"])
         self.append(sym.name, var_accesses)
 
     def indirection_dofmap(self, function_space, operator=None,
@@ -934,8 +945,7 @@ def indirection_dofmap(self, function_space, operator=None,
         '''
         # pylint: disable=unused-argument
         map_name = function_space.cma_indirection_map_name
-        self.append_array_reference(map_name, [":"],
-                                    ScalarType.Intrinsic.INTEGER, tag=map_name)
+        self.append_array_reference(map_name, [":"], tag=map_name)
         self.append(map_name, var_accesses)
 
     def ref_element_properties(self, var_accesses=None):

src/psyclone/domain/lfric/kern_call_arg_list.py

@@ -55,7 +55,7 @@
     ArrayReference, Reference, StructureReference)
 from psyclone.psyir.symbols import (
     DataSymbol, DataTypeSymbol, UnresolvedType, ContainerSymbol,
-    ImportInterface, ScalarType)
+    ImportInterface, ScalarType, ArrayType, UnsupportedFortranType)
 
 # psyir has classes created at runtime
 # pylint: disable=no-member
@@ -138,9 +138,9 @@ def get_user_type(self, module_name, user_type, name, tag=None):
             interface=ImportInterface(module))
         # Declare the actual user symbol in the local symbol table, using
         # the datatype from the root table:
-        sym = self._symtab.new_symbol(name, tag=tag,
-                                      symbol_type=DataSymbol,
-                                      datatype=user_type_symbol)
+        sym = self._symtab.find_or_create(name, tag=tag,
+                                          symbol_type=DataSymbol,
+                                          datatype=user_type_symbol)
         return sym
 
     def append_structure_reference(self, module_name, user_type, member_list,
@@ -207,8 +207,7 @@ def cell_map(self, var_accesses=None):
 
         # Add the cell map to our argument list
         cell_ref_name, cell_ref = self.cell_ref_name(var_accesses)
-        sym = self.append_array_reference(base_name, [":", ":", cell_ref],
-                                          ScalarType.Intrinsic.INTEGER)
+        sym = self.append_array_reference(base_name, [":", ":", cell_ref])
         self.append(f"{sym.name}(:,:,{cell_ref_name})",
                     var_accesses=var_accesses, var_access_name=sym.name)
 
@@ -426,7 +425,6 @@ def stencil_unknown_extent(self, arg, var_accesses=None):
         var_sym = LFRicStencils.dofmap_size_symbol(self._symtab, arg)
         cell_name, cell_ref = self.cell_ref_name(var_accesses)
         self.append_array_reference(var_sym.name, [cell_ref],
-                                    ScalarType.Intrinsic.INTEGER,
                                     symbol=var_sym)
         self.append(f"{var_sym.name}({cell_name})", var_accesses,
                     var_access_name=var_sym.name)
@@ -451,7 +449,6 @@ def stencil_2d_unknown_extent(self, arg, var_accesses=None):
         var_sym = LFRicStencils.dofmap_size_symbol(self._symtab, arg)
         cell_name, cell_ref = self.cell_ref_name(var_accesses)
         self.append_array_reference(var_sym.name, [":", cell_ref],
-                                    ScalarType.Intrinsic.INTEGER,
                                     symbol=var_sym)
         name = f"{var_sym.name}(:,{cell_name})"
         self.append(name, var_accesses, var_access_name=var_sym.name)
@@ -523,7 +520,6 @@ def stencil(self, arg, var_accesses=None):
         var_sym = LFRicStencils.dofmap_symbol(self._symtab, arg)
         cell_name, cell_ref = self.cell_ref_name(var_accesses)
         self.append_array_reference(var_sym.name, [":", ":", cell_ref],
-                                    ScalarType.Intrinsic.INTEGER,
                                     symbol=var_sym)
         self.append(f"{var_sym.name}(:,:,{cell_name})", var_accesses,
                     var_access_name=var_sym.name)
@@ -556,7 +552,6 @@ def stencil_2d(self, arg, var_accesses=None):
         cell_name, cell_ref = self.cell_ref_name(var_accesses)
         self.append_array_reference(var_sym.name,
                                     [":", ":", ":", cell_ref],
-                                    ScalarType.Intrinsic.INTEGER,
                                     symbol=var_sym)
         name = f"{var_sym.name}(:,:,:,{cell_name})"
         self.append(name, var_accesses, var_access_name=var_sym.name)
@@ -639,17 +634,26 @@ def fs_compulsory_field(self, function_space, var_accesses=None):
         self.append(sym.name, var_accesses)
 
         map_name = function_space.map_name
+        intrinsic_type = LFRicTypes("LFRicIntegerScalarDataType")()
+        dtype = UnsupportedFortranType(
+            f"{intrinsic_type.intrinsic.name}("
+            f"kind={intrinsic_type.precision.name}), pointer, "
+            f"dimension(:,:) :: {map_name} => null()",
+            partial_datatype=ArrayType(
+                intrinsic_type,
+                [ArrayType.Extent.DEFERRED, ArrayType.Extent.DEFERRED]))
+        sym = self._symtab.find_or_create_tag(
+            map_name, symbol_type=DataSymbol, datatype=dtype)
+
         if self._kern.iterates_over == 'domain':
             # This kernel takes responsibility for iterating over cells so
             # pass the whole dofmap.
-            sym = self.append_array_reference(map_name, [":", ":"],
-                                              ScalarType.Intrinsic.INTEGER)
+            self.append_array_reference(map_name, [":", ":"], symbol=sym)
             self.append(sym.name, var_accesses, var_access_name=sym.name)
         else:
             # Pass the dofmap for the cell column
             cell_name, cell_ref = self.cell_ref_name(var_accesses)
-            sym = self.append_array_reference(map_name, [":", cell_ref],
-                                              ScalarType.Intrinsic.INTEGER)
+            self.append_array_reference(map_name, [":", cell_ref], symbol=sym)
             self.append(f"{sym.name}(:,{cell_name})",
                         var_accesses, var_access_name=sym.name)
 
@@ -675,8 +679,7 @@ def fs_intergrid(self, function_space, var_accesses=None):
             sym = self.append_integer_reference(function_space.undf_name)
             self.append(sym.name, var_accesses)
             map_name = function_space.map_name
-            sym = self.append_array_reference(map_name, [":", ":"],
-                                              ScalarType.Intrinsic.INTEGER)
+            sym = self.append_array_reference(map_name, [":", ":"])
             self.append(sym.name, var_accesses)
         else:
             # For the coarse mesh we only need undf and the dofmap for
@@ -699,8 +702,10 @@ def basis(self, function_space, var_accesses=None):
         '''
         for rule in self._kern.qr_rules.values():
             basis_name = function_space.get_basis_name(qr_var=rule.psy_name)
-            sym = self.append_array_reference(basis_name, [":", ":", ":", ":"],
-                                              ScalarType.Intrinsic.REAL)
+            sym = self.append_array_reference(
+                    basis_name, [":", ":", ":", ":"],
+                    LFRicTypes("LFRicRealScalarDataType")()
+                )
             self.append(sym.name, var_accesses)
 
         if "gh_evaluator" in self._kern.eval_shapes:
@@ -712,8 +717,7 @@ def basis(self, function_space, var_accesses=None):
                 # function space
                 fspace = self._kern.eval_targets[fs_name][0]
                 basis_name = function_space.get_basis_name(on_space=fspace)
-                sym = self.append_array_reference(basis_name, [":", ":", ":"],
-                                                  ScalarType.Intrinsic.REAL)
+                sym = self.append_array_reference(basis_name, [":", ":", ":"])
                 self.append(sym.name, var_accesses)
 
     def diff_basis(self, function_space, var_accesses=None):
@@ -733,9 +737,11 @@ def diff_basis(self, function_space, var_accesses=None):
         for rule in self._kern.qr_rules.values():
             diff_basis_name = function_space.get_diff_basis_name(
                 qr_var=rule.psy_name)
-            sym = self.append_array_reference(diff_basis_name,
-                                              [":", ":", ":", ":"],
-                                              ScalarType.Intrinsic.REAL)
+            sym = self.append_array_reference(
+                    diff_basis_name,
+                    [":", ":", ":", ":"],
+                    LFRicTypes("LFRicRealScalarDataType")()
+            )
             self.append(sym.name, var_accesses)
 
         if "gh_evaluator" in self._kern.eval_shapes:
@@ -748,9 +754,10 @@ def diff_basis(self, function_space, var_accesses=None):
                 fspace = self._kern.eval_targets[fs_name][0]
                 diff_basis_name = function_space.get_diff_basis_name(
                     on_space=fspace)
-                sym = self.append_array_reference(diff_basis_name,
-                                                  [":", ":", ":"],
-                                                  ScalarType.Intrinsic.REAL)
+                sym = self.append_array_reference(
+                                  diff_basis_name,
+                                  [":", ":", ":"],
+                                  LFRicTypes("LFRicRealScalarDataType")())
                 self.append(sym.name, var_accesses)
 
     def field_bcs_kernel(self, function_space, var_accesses=None):
@@ -784,8 +791,7 @@ def field_bcs_kernel(self, function_space, var_accesses=None):
                 f"{self._kern.name} but got '{farg.argument_type}'")
 
         base_name = "boundary_dofs_" + farg.name
-        sym = self.append_array_reference(base_name, [":", ":"],
-                                          ScalarType.Intrinsic.INTEGER)
+        sym = self.append_array_reference(base_name, [":", ":"])
         self.append(sym.name, var_accesses)
 
     def operator_bcs_kernel(self, function_space, var_accesses=None):
@@ -805,8 +811,7 @@ def operator_bcs_kernel(self, function_space, var_accesses=None):
         # Checks for this are performed in ArgOrdering.generate()
         op_arg = self._kern.arguments.args[0]
         base_name = "boundary_dofs_" + op_arg.name
-        sym = self.append_array_reference(base_name, [":", ":"],
-                                          ScalarType.Intrinsic.INTEGER)
+        sym = self.append_array_reference(base_name, [":", ":"])
         self.append(sym.name, var_accesses)
 
     def mesh_properties(self, var_accesses=None):
@@ -877,14 +882,14 @@ def quad_rule(self, var_accesses=None):
                     self.append_integer_reference(arg)
                 elif generic_name in ["weights_xy", "weights_z"]:
                     # 1d arrays:
-                    # TODO # 1910: These should be pointers
-                    self.append_array_reference(arg, [":"],
-                                                ScalarType.Intrinsic.REAL)
+                    self.append_array_reference(
+                                  arg, [":"],
+                                  LFRicTypes("LFRicRealScalarDataType")())
                 elif generic_name in ["weights_xyz"]:
                     # 2d arrays:
-                    # TODO #1910: These should be pointers
-                    self.append_array_reference(arg, [":", ":"],
-                                                ScalarType.Intrinsic.REAL)
+                    self.append_array_reference(
+                                  arg, [":", ":"],
+                                  LFRicTypes("LFRicRealScalarDataType")())
                 else:
                     raise InternalError(f"Found invalid kernel argument "
                                         f"'{arg}'.")
@@ -970,11 +975,15 @@ def cell_ref_name(self, var_accesses=None):
                 # If there is only one colourmap we need to specify the tag
                 # to make sure we get the right symbol.
                 tag = "cmap"
-            array_ref = self.get_array_reference(self._kern.colourmap,
-                                                 [Reference(colour_sym),
-                                                  Reference(cell_sym)],
-                                                 ScalarType.Intrinsic.INTEGER,
-                                                 tag=tag)
+            symbol = self._symtab.find_or_create(
+                self._kern.colourmap.name, symbol_type=DataSymbol,
+                datatype=ArrayType(
+                    LFRicTypes("LFRicIntegerScalarDataType")(),
+                    [ArrayType.Extent.DEFERRED, ArrayType.Extent.DEFERRED]),
+                tag=tag)
+            array_ref = ArrayReference.create(
+                    symbol,
+                    [Reference(colour_sym), Reference(cell_sym)])
             if var_accesses is not None:
                 var_accesses.add_access(Signature(colour_sym.name),
                                         AccessType.READ, self._kern)
@@ -984,7 +993,7 @@ def cell_ref_name(self, var_accesses=None):
                                         AccessType.READ,
                                         self._kern, ["colour", "cell"])
 
-            return (self._kern.colourmap + "(colour,cell)",
+            return (self._kern.colourmap.name + "(colour,cell)",
                     array_ref)
 
         if var_accesses is not None: