Merge branch '2846_rename_inlined_routines' of github.com:stfc/PSyclone into 2846_rename_inlined_routines

Author: arporter

changelog

@@ -1,3 +1,9 @@
+   3) PR #3480 for #3478. Updates OMPParallelLoopTrans to correctly
+   use the kwargs approach.
+
+   2) PR #3455 for #3170. Adds support for fields and operators with
+   explicit real32 and real64 kinds.
+
    1) PR #3472 for #3471. Let the transformations get_options method
    account for sub-transformation options.
 

config/psyclone.cfg

@@ -91,7 +91,9 @@ precision_map = i_def: 4,
                 r_solver: 4,
                 r_tran: 8,
                 r_bl: 8,
-                r_um: 8
+                r_um: 8,
+                real64: 8,
+                real32: 4
 
 # Specify whether we generate code to perform runtime correctness checks.
 # Allowed values:

doc/user_guide/lfric.rst

@@ -432,7 +432,7 @@ Mixed Precision
 
 The LFRic API supports the ability to specify the precision required
 by the model via precision variables. To make use of this, the code
-developer must declare scalars, arrays, fields and operators in the algorithm
+developer must declare scalars, arrays, fields and operators in the Algorithm
 layer with the required LFRic-supported precision. In the current
 implementation there are two supported precisions for ``REAL`` data and
 one each for ``INTEGER`` and ``LOGICAL`` data. The actual precision used in
@@ -471,6 +471,10 @@ associated kernel metadata description and their precision:
 +--------------------------+---------------------------------------+-----------+
 | R_TRAN_FIELD_TYPE        | GH_FIELD, GH_REAL                     | R_TRAN    |
 +--------------------------+---------------------------------------+-----------+
+| FIELD_REAL32_TYPE        | GH_FIELD, GH_REAL                     | REAL32    |
++--------------------------+---------------------------------------+-----------+
+| FIELD_REAL64_TYPE        | GH_FIELD, GH_REAL                     | REAL64    |
++--------------------------+---------------------------------------+-----------+
 | INTEGER_FIELD_TYPE       | GH_FIELD, GH_INTEGER                  | I_DEF     |
 +--------------------------+---------------------------------------+-----------+
 | OPERATOR_TYPE            | GH_OPERATOR, GH_REAL                  | R_DEF     |
@@ -479,13 +483,18 @@ associated kernel metadata description and their precision:
 +--------------------------+---------------------------------------+-----------+
 | R_TRAN_OPERATOR_TYPE     | GH_OPERATOR, GH_REAL                  | R_TRAN    |
 +--------------------------+---------------------------------------+-----------+
+| OPERATOR_REAL32_TYPE     | GH_OPERATOR, GH_REAL                  | REAL32    |
++--------------------------+---------------------------------------+-----------+
+| OPERATOR_REAL64_TYPE     | GH_OPERATOR, GH_REAL                  | REAL64    |
++--------------------------+---------------------------------------+-----------+
 | COLUMNWISE_OPERATOR_TYPE | GH_COLUMNWISE_OPERATOR, GH_REAL       | R_SOLVER  |
 +--------------------------+---------------------------------------+-----------+
 
 As can be seen from the above table, the kernel metadata does not
 capture all of the precision options. For example, from the metadata
 it is not possible to determine whether a ``REAL`` scalar, ``REAL`` field
-or ``REAL`` operator has precision ``R_DEF``, ``R_SOLVER`` or ``R_TRAN``.
+or ``REAL`` operator has precision ``R_DEF``, ``R_SOLVER``, ``R_TRAN``
+or one of the Fortran intrinsic precisions (``REAL32``, ``REAL64``).
 
 If a scalar, array, field, or operator is specified with a particular
 precision in the algorithm layer then any associated kernels that it
@@ -601,6 +610,10 @@ outlined in the table below:
 +-------------------------+------------------+--------------+
 | ``r_tran_field_type``   | ``real``         | ``r_tran``   |
 +-------------------------+------------------+--------------+
+| ``field_real32_type``   | ``real``         | ``real32``   |
++-------------------------+------------------+--------------+
+| ``field_real64_type``   | ``real``         | ``real64``   |
++-------------------------+------------------+--------------+
 | ``integer_field_type``  | ``integer``      | ``i_def``    |
 +-------------------------+------------------+--------------+
 
@@ -701,7 +714,8 @@ a message that indicates the problem.
 | Fortran Datatype | Supported Precision      |
 +==================+==========================+
 | ``real``         | ``r_def``, ``r_bl``,     |
-|                  | ``r_solver``, ``r_tran`` |
+|                  | ``r_solver``, ``r_tran``,|
+|                  | ``real32``, ``real64``   |
 +------------------+--------------------------+
 | ``integer``      | ``i_def``                |
 +------------------+--------------------------+
@@ -731,6 +745,10 @@ outlined in the table below:
 +----------------------------+------------------+--------------+
 | ``r_tran_operator_type``   | ``real``         | ``r_tran``   |
 +----------------------------+------------------+--------------+
+| ``operator_real32_type``   | ``real``         | ``real32``   |
++----------------------------+------------------+--------------+
+| ``operator_real64_type``   | ``real``         | ``real64``   |
++----------------------------+------------------+--------------+
 
 .. _lfric-mixed-precision-cma-operators:
 

src/psyclone/domain/lfric/lfric_constants.py

@@ -384,6 +384,11 @@ def __init__(self) -> None:
 
         # ---------- Infrastructure module maps -------------------------------
 
+        # Those kind symbols used in LFRic that are actually
+        # Fortran intrinsics (and thus don't come from constants_mod).
+        LFRicConstants.INTRINSIC_KINDS = ("real32", "real64")
+        LFRicConstants.FORTRAN_ISO_MOD_NAME = "iso_fortran_env"
+
         # Dictionary allowing us to look-up the name of the Fortran module,
         # type and proxy-type associated with each LFRic data structure type.
         # Data structure type mandates its proxy name, Fortran intrinsic type
@@ -420,6 +425,18 @@ def __init__(self) -> None:
                            "proxy_type": "r_bl_field_proxy_type",
                            "intrinsic": "real",
                            "kind": "r_bl"},
+            # 'real'-valued field with explicit 32-bit precision
+            "r_32_field": {"module": "field_real32_mod",
+                           "type": "field_real32_type",
+                           "proxy_type": "field_real32_proxy_type",
+                           "intrinsic": "real",
+                           "kind": "real32"},
+            # 'real'-valued field with explicit 64-bit precision
+            "r_64_field": {"module": "field_real64_mod",
+                           "type": "field_real64_type",
+                           "proxy_type": "field_real64_proxy_type",
+                           "intrinsic": "real",
+                           "kind": "real64"},
             # 'integer'-valued field with data of kind 'i_def'
             "integer_field": {"module": "integer_field_mod",
                               "type": "integer_field_type",
@@ -432,6 +449,18 @@ def __init__(self) -> None:
                          "proxy_type": "operator_proxy_type",
                          "intrinsic": "real",
                          "kind": "r_def"},
+            # 'real'-valued operator with real32 data
+            "r_32_operator": {"module": "operator_real32_mod",
+                              "type": "operator_real32_type",
+                              "proxy_type": "operator_real32_proxy_type",
+                              "intrinsic": "real",
+                              "kind": "real32"},
+            # 'real'-valued operator with real32 data
+            "r_64_operator": {"module": "operator_real64_mod",
+                              "type": "operator_real64_type",
+                              "proxy_type": "operator_real64_proxy_type",
+                              "intrinsic": "real",
+                              "kind": "real64"},
             # 'real'-valued operator with data of kind 'r_solver'
             "r_solver_operator": {
                 "module": "r_solver_operator_mod",
@@ -454,6 +483,13 @@ def __init__(self) -> None:
                 "intrinsic": "real",
                 "kind": "r_solver"}}
 
+        # Construct a reverse map from type to the name of the LFRic
+        # data type for all real field types.
+        LFRicConstants.REAL_DATA_TYPE_RMAP = {}
+        for key, value in LFRicConstants.DATA_TYPE_MAP.items():
+            if value["intrinsic"] == "real" and "field" in key:
+                LFRicConstants.REAL_DATA_TYPE_RMAP[value["type"]] = key
+
         # Mapping from a vector type used in the algorithm-layer to
         # the actual type used in the PSy-layer.
         LFRicConstants.FIELD_VECTOR_TO_FIELD_MAP = {

src/psyclone/domain/lfric/lfric_driver_creator.py

@@ -72,7 +72,8 @@ def __init__(self, region_name: Optional[tuple[str, str]] = None) -> None:
     # -------------------------------------------------------------------------
     def handle_precision_symbols(self, symbol_table: SymbolTable) -> None:
         '''This function adds an import of the various precision
-        symbols used by LFRic from the constants_mod module.
+        symbols used by LFRic from the constants_mod module. It also adds
+        imports of the real32 and real64 intrinsic kinds.
 
         :param symbol_table: the symbol table to which the precision symbols
             must be added.
@@ -87,15 +88,27 @@ def handle_precision_symbols(self, symbol_table: SymbolTable) -> None:
         # does not exist at all in LFRic, but is still in LFRic's psyclone.cfg
         # file. TODO #2018 and
         # https://code.metoffice.gov.uk/trac/lfric/ticket/4674
+        names_to_skip = ["r_quad", "r_phys"] + list(const.INTRINSIC_KINDS)
         api_config = Config.get().api_conf("lfric")
         all_precisions = [name for name in api_config.precision_map
-                          if name not in ["r_quad", "r_phys"]]
+                          if name not in names_to_skip]
         for prec_name in all_precisions:
             symbol_table.new_symbol(prec_name,
                                     tag=f"{prec_name}@{mod_name}",
                                     symbol_type=DataSymbol,
                                     datatype=ScalarType.integer_type(),
                                     interface=ImportInterface(constant_mod))
+        # Intrinsic kind symbols are imported into constants_mod but are
+        # private to it so have to be handled separately.
+        iso_mod = ContainerSymbol(const.FORTRAN_ISO_MOD_NAME,
+                                  is_intrinsic=True)
+        symbol_table.add(iso_mod)
+        for prec_name in const.INTRINSIC_KINDS:
+            symbol_table.new_symbol(prec_name,
+                                    tag=f"{prec_name}@{iso_mod.name}",
+                                    symbol_type=DataSymbol,
+                                    datatype=ScalarType.integer_type(),
+                                    interface=ImportInterface(iso_mod))
 
     # -------------------------------------------------------------------------
     def verify_and_cleanup_psyir(self, extract_region: Node) -> None:

src/psyclone/domain/lfric/lfric_types.py

@@ -608,6 +608,9 @@ def add_precision_symbol(table: SymbolTable,
         table then add it. Also ensure that the Container symbol from which it
         is imported is in the table.
 
+        Also supports Fortran intrinsic kinds imported from the
+        iso_fortran_env module.
+
         :param table: the symbol table to use.
         :param name: name of the LFRic precision symbol to add to table.
 
@@ -624,7 +627,13 @@ def add_precision_symbol(table: SymbolTable,
             raise ValueError(f"'{name}' is not a recognised LFRic precision.")
 
         const = LFRicConstants()
-        mod_name = const.UTILITIES_MOD_MAP["constants"]["module"]
+        if name in const.INTRINSIC_KINDS:
+            # This is an intrinsic precision (e.g. real64)
+            mod_name = const.FORTRAN_ISO_MOD_NAME
+            is_intrinsic = True
+        else:
+            mod_name = const.UTILITIES_MOD_MAP["constants"]["module"]
+            is_intrinsic = False
 
         sym = table.lookup(name, otherwise=None)
 
@@ -638,7 +647,8 @@ def add_precision_symbol(table: SymbolTable,
             return sym
 
         constants_mod = table.find_or_create(mod_name,
-                                             symbol_type=ContainerSymbol)
+                                             symbol_type=ContainerSymbol,
+                                             is_intrinsic=is_intrinsic)
         sym = DataSymbol(name, ScalarType.integer_type(),
                          interface=ImportInterface(constants_mod))
         table.add(sym)