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

src/psyclone/domain/lfric/arg_ordering.py

@@ -202,6 +202,14 @@
         from psyclone.domain.lfric import LFRicTypes
         if tag is None:
             tag = name
+        else:
+            # If it has a tag, first try to look up for it
+            try:
+                sym = self._symtab.lookup_with_tag("tag")
+                self.psyir_append(Reference(sym))
+                return sym
+            except KeyError:
+                pass
         sym = self._symtab.find_or_create(
                 name, tag=tag, symbol_type=DataSymbol,
                 datatype=LFRicTypes("LFRicIntegerScalarDataType")())

src/psyclone/domain/lfric/lfric_cell_iterators.py

@@ -66,35 +66,28 @@ def __init__(self, kern_or_invoke):
         # (for invokes) the kernel argument to which each corresponds.
         self._nlayers_names = {}
 
-        if not self._invoke:
-            # We are dealing with a single Kernel so there is only one
-            # 'nlayers' variable and we don't need to store the associated
+        if self._invoke:
+            # Each kernel that operates on either the domain or cell-columns
+            # needs an 'nlayers' obtained from the first field/operator
             # argument.
-            self._nlayers_names[self.symtab.find_or_create_tag(
-                "nlayers",
-                symbol_type=LFRicTypes("MeshHeightDataSymbol")).name] = None
-            # We're not generating a PSy layer so we're done here.
-            return
-
-        # Each kernel that operates on either the domain or cell-columns needs
-        # an 'nlayers' obtained from the first field/operator argument.
-        for kern in self._invoke.schedule.walk(LFRicKern):
-            if kern.iterates_over != "dof":
-                arg = kern.arguments.first_field_or_operator
-                sym = self.symtab.find_or_create_tag(
-                    f"nlayers_{arg.name}",
-                    symbol_type=LFRicTypes("MeshHeightDataSymbol"))
-                self._nlayers_names[sym.name] = arg
-
-        first_var = None
-        for var in self._invoke.psy_unique_vars:
-            if not var.is_scalar:
-                first_var = var
-                break
-        if not first_var:
-            raise GenerationError(
-                "Cannot create an Invoke with no field/operator arguments.")
-        self._first_var = first_var
+            for kern in self._invoke.schedule.walk(LFRicKern):
+                if kern.iterates_over != "dof":
+                    arg = kern.arguments.first_field_or_operator
+                    sym = self.symtab.find_or_create_tag(
+                        f"nlayers_{arg.name}",
+                        symbol_type=LFRicTypes("MeshHeightDataSymbol"))
+                    self._nlayers_names[sym.name] = arg
+
+            first_var = None
+            for var in self._invoke.psy_unique_vars:
+                if not var.is_scalar:
+                    first_var = var
+                    break
+            if not first_var:
+                raise GenerationError(
+                    "Cannot create an Invoke with no field/operator "
+                    "arguments.")
+            self._first_var = first_var
 
     def stub_declarations(self):
         '''
@@ -104,13 +97,13 @@ def stub_declarations(self):
         '''
         super().stub_declarations()
         if self._kernel.cma_operation not in ["apply", "matrix-matrix"]:
-            for name in self._nlayers_names:
-                sym = self.symtab.lookup(name)
-                # Symbols are created as though for an Invoke context, so make
-                # sure they are arguments when we are in a Stub context.
-                sym.interface = ArgumentInterface(
-                    ArgumentInterface.Access.READ)
-                self.symtab.append_argument(sym)
+            nlayers = self.symtab.find_or_create_tag(
+                "nlayers",
+                symbol_type=LFRicTypes("MeshHeightDataSymbol")
+            )
+            nlayers.interface = ArgumentInterface(
+                                        ArgumentInterface.Access.READ)
+            self.symtab.append_argument(nlayers)
 
     def initialise(self, cursor):
         '''

src/psyclone/domain/lfric/lfric_dofmaps.py

@@ -288,7 +288,14 @@ def stub_declarations(self):
             symbol.interface = ArgumentInterface(ArgumentInterface.Access.READ)
             self.symtab.append_argument(symbol)
 
-            nlayers = self.symtab.lookup("nlayers")
+            nlayers = self.symtab.find_or_create_tag(
+                "nlayers",
+                symbol_type=LFRicTypes("MeshHeightDataSymbol")
+            )
+            nlayers.interface = ArgumentInterface(
+                                        ArgumentInterface.Access.READ)
+            self.symtab.append_argument(nlayers)
+
             dmap_symbol = self.symtab.find_or_create(
                 dmap, symbol_type=DataSymbol,
                 datatype=ArrayType(LFRicTypes("LFRicIntegerScalarDataType")(),

src/psyclone/domain/lfric/lfric_kern.py

@@ -60,8 +60,7 @@
     Loop, Literal, Reference, KernelSchedule, Container, Routine)
 from psyclone.psyir.symbols import (
     DataSymbol, ScalarType, ArrayType, UnsupportedFortranType, DataTypeSymbol,
-    UnresolvedType, ContainerSymbol, UnknownInterface, INTEGER_TYPE,
-    UnresolvedInterface)
+    UnresolvedType, ContainerSymbol, INTEGER_TYPE, UnresolvedInterface)
 
 
 class LFRicKern(CodedKern):
@@ -719,11 +718,6 @@ def gen_stub(self) -> Container:
         arg_list = []
         for argument_name in create_arg_list.arglist:
             arg_list.append(stub_routine.symbol_table.lookup(argument_name))
-        # If a previous argument has not been given an order by KernStubArgList
-        # ignore it.
-        for argument in stub_routine.symbol_table.argument_list:
-            if argument not in arg_list:
-                argument.interface = UnknownInterface()
         stub_routine.symbol_table.specify_argument_list(arg_list)
 
         return stub_module

src/psyclone/domain/lfric/lfric_loop_bounds.py

@@ -39,8 +39,8 @@
 ''' This module provides the LFRicLoopBounds Class that handles all variables
     required for specifying loop limits within an LFRic PSy-layer routine.'''
 
-from psyclone.domain.lfric import LFRicCollection
-from psyclone.psyir.nodes import Assignment, Reference, Loop
+from psyclone.domain.lfric import LFRicCollection, LFRicLoop
+from psyclone.psyir.nodes import Assignment, Reference
 
 
 class LFRicLoopBounds(LFRicCollection):
@@ -59,16 +59,13 @@ def initialise(self, cursor: int) -> int:
         :returns: Updated cursor value.
 
         '''
-        loops = self._invoke.schedule.loops()
-
-        if not loops:
-            return cursor
+        loops = filter(lambda x: isinstance(x, LFRicLoop),
+                       self._invoke.schedule.loops())
 
         first = True
         for idx, loop in enumerate(loops):
 
-            # pylint: disable=unidiomatic-typecheck
-            if type(loop) is Loop or loop.loop_type == "null":
+            if loop.loop_type == "null":
                 # Generic or 'null' loops don't need any variables to be set
                 continue
 

src/psyclone/dynamo0p3.py

@@ -3616,7 +3616,8 @@ def initialise(self, cursor):
                 Assignment.create(
                     lhs=Reference(self.symtab.lookup(name)),
                     rhs=dofs.argument.generate_method_call(
-                                                "get_boundary_dofs"),
+                        "get_boundary_dofs",
+                        function_space=dofs.function_space),
                     is_pointer=True
                 ),
                 cursor)

src/psyclone/psyGen.py

@@ -1120,7 +1120,7 @@ def zero_reduction_variable(self):
                 f"'{var_arg.intrinsic_type}'.")
 
         # Retrieve the variable and precision information
-        kind_str = f"kind={var_arg.precision}" if var_arg.precision else ""
+        kind_str = f"(kind={var_arg.precision})" if var_arg.precision else ""
         variable = self.scope.symbol_table.lookup(variable_name)
         insert_loc = self.ancestor(PSyLoop)
         # If it has ancestor directive keep going up
@@ -1138,7 +1138,7 @@ def zero_reduction_variable(self):
             local_var = self.scope.symbol_table.find_or_create_tag(
                 local_var_name, symbol_type=DataSymbol,
                 datatype=UnsupportedFortranType(
-                    f"{var_data_type}({kind_str}), allocatable, "
+                    f"{var_data_type}{kind_str}, allocatable, "
                     f"dimension(:,:) :: {local_var_name}"
                 ))
             nthreads = \

src/psyclone/psyir/symbols/symbol_table.py

@@ -286,7 +286,12 @@ def deep_copy(self):
 
         # Prepare the new tag dict
         for tag, symbol in self._tags.items():
-            new_st._tags[tag] = new_st.lookup(symbol.name)
+            try:
+                new_st._tags[tag] = new_st.lookup(symbol.name)
+            except KeyError:
+                # TODO 898: If the lookup fails it means that the symbol was
+                # removed from the symbol table but not the tags dictionary
+                pass
 
         # Update any references to Symbols within Symbols (initial values,
         # precision etc.)

src/psyclone/psyir/transformations/loop_fuse_trans.py

@@ -42,7 +42,7 @@ class for all API-specific loop fusion transformations.
 
 from psyclone.core import SymbolicMaths
 from psyclone.domain.common.psylayer import PSyLoop
-from psyclone.psyir.nodes import Reference
+from psyclone.psyir.nodes import Reference, Routine
 from psyclone.psyir.tools import DependencyTools
 from psyclone.psyir.transformations.loop_trans import LoopTrans
 from psyclone.psyir.transformations.transformation_error import \
@@ -198,6 +198,21 @@ def apply(self, node1, node2, options=None):
         # Add loop contents of node2 to node1
         node1.loop_body.children.extend(node2.loop_body.pop_all_children())
 
+        # We need to remove all leftover references because lfric is compiled
+        # with '-Werror=unused-variable'
+        routine = node1.ancestor(Routine)
+        if routine:
+            remaining_syms = [r.symbol for r in routine.walk(Reference)]
+            del_syms = [r.symbol for r in node2.start_expr.walk(Reference) +
+                        node2.stop_expr.walk(Reference)]
+            for rsym in del_syms:
+                if rsym not in remaining_syms:
+                    if rsym.is_automatic:
+                        symtab = rsym.find_symbol_table(node1)
+                        # TODO #898: Implement symbol removal
+                        # pylint: disable=protected-access
+                        symtab._symbols.pop(rsym.name)
+
 
 # For automatic documentation generation
 __all__ = ["LoopFuseTrans"]

src/psyclone/psyir/transformations/omp_loop_trans.py

@@ -38,7 +38,8 @@
 from psyclone.configuration import Config
 from psyclone.psyir.nodes import (
     OMPDoDirective, OMPLoopDirective, OMPParallelDoDirective,
-    OMPTeamsDistributeParallelDoDirective, OMPScheduleClause)
+    OMPTeamsLoopDirective, OMPTeamsDistributeParallelDoDirective,
+    OMPScheduleClause)
 from psyclone.psyir.transformations.parallel_loop_trans import \
     ParallelLoopTrans
 

src/psyclone/tests/domain/gocean/transformations/gocean_extract_test.py

@@ -225,7 +225,7 @@ def test_single_node_ompparalleldo_gocean1p0():
     code = str(psy.gen)
     output = """
     CALL extract_psy_data % PreStart("psy_single_invoke_three_kernels", """ \
-    """"invoke_0-compute_cv_code-r0", 6, 3)
+    """"invoke_0-compute_cv_code-r0", 9, 3)
     CALL extract_psy_data % PreDeclareVariable("cv_fld%internal%xstart", """ \
                                              """cv_fld % internal % xstart)
     CALL extract_psy_data % PreDeclareVariable("cv_fld%internal%xstop", """ \
@@ -236,6 +236,9 @@ def test_single_node_ompparalleldo_gocean1p0():
                                              """cv_fld % internal % ystop)
     CALL extract_psy_data % PreDeclareVariable("p_fld", p_fld)
     CALL extract_psy_data % PreDeclareVariable("v_fld", v_fld)
+    CALL extract_psy_data % PreDeclareVariable("cv_fld", cv_fld)
+    CALL extract_psy_data % PreDeclareVariable("i", i)
+    CALL extract_psy_data % PreDeclareVariable("j", j)
     CALL extract_psy_data % PreDeclareVariable("cv_fld_post", cv_fld)
     CALL extract_psy_data % PreDeclareVariable("i_post", i)
     CALL extract_psy_data % PreDeclareVariable("j_post", j)
@@ -250,6 +253,9 @@ def test_single_node_ompparalleldo_gocean1p0():
                                           """cv_fld % internal % ystop)
     CALL extract_psy_data % ProvideVariable("p_fld", p_fld)
     CALL extract_psy_data % ProvideVariable("v_fld", v_fld)
+    CALL extract_psy_data % ProvideVariable("cv_fld", cv_fld)
+    CALL extract_psy_data % ProvideVariable("i", i)
+    CALL extract_psy_data % ProvideVariable("j", j)
     CALL extract_psy_data % PreEnd
     !$omp parallel do default(shared), private(i,j), schedule(static)
     do j = cv_fld%internal%ystart, cv_fld%internal%ystop, 1
@@ -297,11 +303,14 @@ def test_single_node_ompparalleldo_gocean1p0_const_loop():
     code = str(psy.gen)
     output = """
     CALL extract_psy_data % PreStart("psy_single_invoke_three_kernels", """ \
-    """"invoke_0-compute_cv_code-r0", 4, 3)
+    """"invoke_0-compute_cv_code-r0", 7, 3)
     CALL extract_psy_data % PreDeclareVariable("istop", istop)
     CALL extract_psy_data % PreDeclareVariable("jstop", jstop)
     CALL extract_psy_data % PreDeclareVariable("p_fld", p_fld)
     CALL extract_psy_data % PreDeclareVariable("v_fld", v_fld)
+    CALL extract_psy_data % PreDeclareVariable("cv_fld", cv_fld)
+    CALL extract_psy_data % PreDeclareVariable("i", i)
+    CALL extract_psy_data % PreDeclareVariable("j", j)
     CALL extract_psy_data % PreDeclareVariable("cv_fld_post", cv_fld)
     CALL extract_psy_data % PreDeclareVariable("i_post", i)
     CALL extract_psy_data % PreDeclareVariable("j_post", j)
@@ -310,6 +319,9 @@ def test_single_node_ompparalleldo_gocean1p0_const_loop():
     CALL extract_psy_data % ProvideVariable("jstop", jstop)
     CALL extract_psy_data % ProvideVariable("p_fld", p_fld)
     CALL extract_psy_data % ProvideVariable("v_fld", v_fld)
+    CALL extract_psy_data % ProvideVariable("cv_fld", cv_fld)
+    CALL extract_psy_data % ProvideVariable("i", i)
+    CALL extract_psy_data % ProvideVariable("j", j)
     CALL extract_psy_data % PreEnd
     !$omp parallel do default(shared), private(i,j), schedule(static)
     do j = 2, jstop + 1, 1
@@ -360,12 +372,16 @@ def test_node_list_ompparallel_gocean1p0():
     code = str(psy.gen)
     output = """
     CALL extract_psy_data % PreStart("psy_single_invoke_three_kernels", """ \
-    """"invoke_0-r0", 5, 4)
+    """"invoke_0-r0", 9, 4)
     CALL extract_psy_data % PreDeclareVariable("istop", istop)
     CALL extract_psy_data % PreDeclareVariable("jstop", jstop)
     CALL extract_psy_data % PreDeclareVariable("p_fld", p_fld)
     CALL extract_psy_data % PreDeclareVariable("u_fld", u_fld)
     CALL extract_psy_data % PreDeclareVariable("v_fld", v_fld)
+    CALL extract_psy_data % PreDeclareVariable("cu_fld", cu_fld)
+    CALL extract_psy_data % PreDeclareVariable("cv_fld", cv_fld)
+    CALL extract_psy_data % PreDeclareVariable("i", i)
+    CALL extract_psy_data % PreDeclareVariable("j", j)
     CALL extract_psy_data % PreDeclareVariable("cu_fld_post", cu_fld)
     CALL extract_psy_data % PreDeclareVariable("cv_fld_post", cv_fld)
     CALL extract_psy_data % PreDeclareVariable("i_post", i)
@@ -376,6 +392,10 @@ def test_node_list_ompparallel_gocean1p0():
     CALL extract_psy_data % ProvideVariable("p_fld", p_fld)
     CALL extract_psy_data % ProvideVariable("u_fld", u_fld)
     CALL extract_psy_data % ProvideVariable("v_fld", v_fld)
+    CALL extract_psy_data % ProvideVariable("cu_fld", cu_fld)
+    CALL extract_psy_data % ProvideVariable("cv_fld", cv_fld)
+    CALL extract_psy_data % ProvideVariable("i", i)
+    CALL extract_psy_data % ProvideVariable("j", j)
     CALL extract_psy_data % PreEnd
     !$omp parallel default(shared), private(i,j)
     !$omp do schedule(static)

src/psyclone/tests/domain/lfric/dofkern_test.py

@@ -184,7 +184,8 @@ def test_indexed_field_args(tmpdir):
     code = str(psy.gen)
 
     expected = ("call testkern_dofs_code(f1_data(df), f2_data(df), "
-                "f3_data(df), f4_data(df), scalar_arg)")
+                "f3_data(df), f4_data(df), field_vec_1_data(df), "
+                "field_vec_2_data(df), field_vec_3_data(df), scalar_arg)")
 
     assert expected in code
     # Check compilation
@@ -268,6 +269,7 @@ def test_multi_invoke_cell_dof_builtin(tmpdir, monkeypatch, annexed, dist_mem):
     type(field_type), intent(in) :: f2
     type(field_type), intent(in) :: f3
     type(field_type), intent(in) :: f4
+    type(field_type), dimension(3), intent(in) :: field_vec
     real(kind=r_def), intent(in) :: scalar_arg
     real(kind=r_def), intent(in) :: a
     type(field_type), intent(in) :: m1
@@ -278,6 +280,9 @@ def test_multi_invoke_cell_dof_builtin(tmpdir, monkeypatch, annexed, dist_mem):
     real(kind=r_def), pointer, dimension(:) :: f2_data => null()
     real(kind=r_def), pointer, dimension(:) :: f3_data => null()
     real(kind=r_def), pointer, dimension(:) :: f4_data => null()
+    real(kind=r_def), pointer, dimension(:) :: field_vec_1_data => null()
+    real(kind=r_def), pointer, dimension(:) :: field_vec_2_data => null()
+    real(kind=r_def), pointer, dimension(:) :: field_vec_3_data => null()
     real(kind=r_def), pointer, dimension(:) :: m1_data => null()
     real(kind=r_def), pointer, dimension(:) :: m2_data => null()
     """ in code
@@ -286,7 +291,8 @@ def test_multi_invoke_cell_dof_builtin(tmpdir, monkeypatch, annexed, dist_mem):
     output = (
         "    do df = loop0_start, loop0_stop, 1\n"
         "      call testkern_dofs_code(f1_data(df), f2_data(df), "
-        "f3_data(df), f4_data(df), scalar_arg)\n"
+        "f3_data(df), f4_data(df), field_vec_1_data(df), "
+        "field_vec_2_data(df), field_vec_3_data(df), scalar_arg)\n"
         "    enddo\n"
     )
     assert output in code
@@ -299,7 +305,8 @@ def test_multi_invoke_cell_dof_builtin(tmpdir, monkeypatch, annexed, dist_mem):
             output = (
                 "    do df = loop0_start, loop0_stop, 1\n"
                 "      call testkern_dofs_code(f1_data(df), f2_data(df), "
-                "f3_data(df), f4_data(df), scalar_arg)\n"
+                "f3_data(df), f4_data(df), field_vec_1_data(df), "
+                "field_vec_2_data(df), field_vec_3_data(df), scalar_arg)\n"
                 "    enddo\n"
                 "\n"
                 "    ! Set halos dirty/clean for fields modified in the "
@@ -312,7 +319,8 @@ def test_multi_invoke_cell_dof_builtin(tmpdir, monkeypatch, annexed, dist_mem):
             output = (
                 "    do df = loop0_start, loop0_stop, 1\n"
                 "      call testkern_dofs_code(f1_data(df), f2_data(df), "
-                "f3_data(df), f4_data(df), scalar_arg)\n"
+                "f3_data(df), f4_data(df), field_vec_1_data(df), "
+                "field_vec_2_data(df), field_vec_3_data(df), scalar_arg)\n"
                 "    enddo\n"
                 "\n"
                 "    ! Set halos dirty/clean for fields modified in the "