(Towards #2381 #2674) add min max access types and new LFRic builtins

config/psyclone.cfg

@@ -64,7 +64,8 @@ FORTRAN_STANDARD = f2008
 # ==================================
 [lfric]
 access_mapping = gh_read: read, gh_write: write, gh_readwrite: readwrite,
-                 gh_inc: inc, gh_readinc: readinc, gh_sum: sum
+                 gh_inc: inc, gh_readinc: readinc, gh_sum: sum,
+		 gh_min: min, gh_max: max
 
 # Specify whether we compute annexed dofs when a kernel is written so
 # that it iterates over dofs. This is currently only the case for

doc/user_guide/lfric.rst

@@ -2797,7 +2797,8 @@ are listed in the table below.
 +===============+=====================+================+====================+
 | GH_SCALAR     | GH_INTEGER          | n/a            | GH_READ            |
 +---------------+---------------------+----------------+--------------------+
-| GH_SCALAR     | GH_REAL             | n/a            | GH_READ, GH_SUM    |
+| GH_SCALAR     | GH_REAL             | n/a            | GH_READ, GH_SUM,   |
+|               |                     |                | GH_MIN, GH_MAX     |
 +---------------+---------------------+----------------+--------------------+
 | GH_FIELD      | GH_REAL, GH_INTEGER | ANY_SPACE_<n>  | GH_READ, GH_WRITE, |
 |               |                     |                | GH_READWRITE       |
@@ -3455,6 +3456,34 @@ the same field (``X = min(a, X)``)::
 
   field(:) = MIN(rscalar, field(:))
 
+Global minimum and maximum field-element values
+###############################################
+
+Built-ins which scan through all elements of a field and return its
+maximum or minimum value.
+
+.. warning::
+   Support for these built-ins is not yet complete and therefore they
+   cannot currently be used. TODO #2381.
+
+minval_X
+^^^^^^^^
+
+**minval_X** (*rscalar*, **field**)
+
+Returns the minimum value held in the field *field*::
+
+  rscalar = MINVAL(field(:))
+
+maxval_X
+^^^^^^^^
+
+**maxval_X** (*rscalar*, **field**)
+
+Returns the maximum value held in the field *field*::
+
+  rscalar = MAXVAL(field(:))
+
 Conversion of ``real`` field elements
 #####################################
 

src/psyclone/configuration.py

@@ -815,7 +815,7 @@ def __init__(self, section):
         # having to specify those mappings.
         self._access_mapping = {"read": "read", "write": "write",
                                 "readwrite": "readwrite", "inc": "inc",
-                                "sum": "sum"}
+                                "sum": "sum", "min": "min", "max": "max"}
         # Get the mapping if one exists and convert it into a
         # dictionary. The input is in the format: key1:value1,
         # key2=value2, ...

src/psyclone/core/access_type.py

@@ -37,6 +37,7 @@
 
 '''This module implements the AccessType used throughout PSyclone.'''
 
+from __future__ import annotations
 from enum import Enum
 from psyclone.configuration import Config
 
@@ -75,6 +76,10 @@ class AccessType(Enum):
     #: is available at compile-time and can be used for type properties such
     #: as kinds or dimensions.
     CONSTANT = 10
+    #: Is the output of a MIN reduction (i.e. global minimum value).
+    MIN = 11
+    #: Is the output of a MAX reduction (i.e. global maximum value).
+    MAX = 12
 
     def __str__(self) -> str:
         '''Convert to a string representation, returning just the
@@ -132,12 +137,11 @@ def all_read_accesses():
                 AccessType.READINC]
 
     @staticmethod
-    def get_valid_reduction_modes():
+    def get_valid_reduction_modes() -> list[AccessType]:
         '''
         :returns: A list of valid reduction access modes.
-        :rtype: List of py:class:`psyclone.core.access_type.AccessType`.
         '''
-        return [AccessType.SUM]
+        return [AccessType.SUM, AccessType.MIN, AccessType.MAX]
 
     @staticmethod
     def get_valid_reduction_names():

src/psyclone/domain/lfric/lfric_builtins.py

@@ -311,6 +311,10 @@ def _validate(self):
         write_count = 0  # Only one argument must be written to
         field_count = 0  # We must have one or more fields as arguments
         spaces = set()   # All field arguments must be on the same space
+        # Built-ins update fields DoF by DoF and therefore can have
+        # WRITE/READWRITE access
+        write_access_modes = AccessType.get_valid_reduction_modes() + [
+            AccessType.WRITE, AccessType.READWRITE]
         # Field data types must be the same except for the conversion built-ins
         data_types = set()
         for arg in self.arg_descriptors:
@@ -328,10 +332,8 @@ def _validate(self):
                     f"must have one of {const.VALID_BUILTIN_DATA_TYPES} as "
                     f"a data type but kernel '{self.name}' has an argument "
                     f"of data type '{arg.data_type}'.")
-            # Built-ins update fields DoF by DoF and therefore can have
-            # WRITE/READWRITE access
-            if arg.access in [AccessType.WRITE, AccessType.SUM,
-                              AccessType.READWRITE]:
+            # Check for write accesses
+            if arg.access in write_access_modes:
                 write_count += 1
             if arg.argument_type in const.VALID_FIELD_NAMES:
                 field_count += 1
@@ -2743,6 +2745,88 @@ def lower_to_language_level(self) -> Node:
         # Create assignment and replace node
         return self._replace_with_assignment(lhs, rhs)
 
+# ------------------------------------------------------------------- #
+# ============ Minimum, maximum value of real field elements) ======= #
+# ------------------------------------------------------------------- #
+
+
+class LFRicMinvalXKern(LFRicBuiltIn):
+    '''
+    Computes the (global) minimum scalar value held in
+    the supplied field.
+    '''
+    _case_name = "minval_X"
+    _datatype = "real"
+
+    @classmethod
+    def metadata(cls) -> LFRicKernelMetadata:
+        """
+        :returns: kernel metadata describing this built-in.
+        """
+        return cls._builtin_metadata([
+            ScalarArgMetadata("gh_real", "gh_min"),
+            FieldArgMetadata("gh_real", "gh_read", "any_space_1")])
+
+    def __str__(self):
+        return (f"Built-in: {self._case_name} (compute the global minimum "
+                f"value contained in a field)")
+
+    def lower_to_language_level(self) -> Node:
+        '''
+        Lowers this LFRic-specific built-in kernel to language-level PSyIR.
+        This BuiltIn node is replaced by an Assignment node.
+
+        :returns: the lowered version of this node.
+
+        '''
+        super().lower_to_language_level()
+        # Get indexed references for the field (proxy) argument.
+        arg_refs = self.get_indexed_field_argument_references()
+        # Get a reference for the kernel scalar reduction argument.
+        lhs = self._reduction_reference()
+        minval = IntrinsicCall.create(IntrinsicCall.Intrinsic.MIN,
+                                      [lhs.copy(), arg_refs[0]])
+        return self._replace_with_assignment(lhs, minval)
+
+
+class LFRicMaxvalXKern(LFRicBuiltIn):
+    '''
+    Computes the (global) maximum scalar value held in
+    the supplied field.
+    '''
+    _case_name = "maxval_X"
+    _datatype = "real"
+
+    @classmethod
+    def metadata(cls) -> LFRicKernelMetadata:
+        """
+        :returns: kernel metadata describing this built-in.
+        """
+        return cls._builtin_metadata([
+            ScalarArgMetadata("gh_real", "gh_max"),
+            FieldArgMetadata("gh_real", "gh_read", "any_space_1")])
+
+    def __str__(self):
+        return (f"Built-in: {self._case_name} (compute the global maximum "
+                f"value contained in a field)")
+
+    def lower_to_language_level(self) -> Node:
+        '''
+        Lowers this LFRic-specific built-in kernel to language-level PSyIR.
+        This BuiltIn node is replaced by an Assignment node.
+
+        :returns: the lowered version of this node.
+
+        '''
+        super().lower_to_language_level()
+        # Get indexed references for the field (proxy) argument.
+        arg_refs = self.get_indexed_field_argument_references()
+        # Get a reference for the kernel scalar reduction argument.
+        lhs = self._reduction_reference()
+        minval = IntrinsicCall.create(IntrinsicCall.Intrinsic.MAX,
+                                      [lhs.copy(), arg_refs[0]])
+        return self._replace_with_assignment(lhs, minval)
+
 # ------------------------------------------------------------------- #
 # ============== Converting real to integer field elements ========== #
 # ------------------------------------------------------------------- #
@@ -3270,6 +3354,9 @@ def lower_to_language_level(self) -> Node:
     # Minimum of a real scalar value and real field elements
     "min_aX": LFRicMinAXKern,
     "inc_min_aX": LFRicIncMinAXKern,
+    # Minimum and maximum values contained in a field
+    "minval_X": LFRicMinvalXKern,
+    "maxval_X": LFRicMaxvalXKern,
     # Converting real to integer field elements
     "real_to_int_X": LFRicRealToIntXKern,
     # Converting real to real field elements

src/psyclone/domain/lfric/lfric_constants.py

@@ -114,8 +114,9 @@ def __init__(self) -> None:
         # pylint: disable=too-many-instance-attributes
 
         # Supported access types
-        # gh_sum for scalars is restricted to iterates_over == 'dof'
-        LFRicConstants.VALID_SCALAR_ACCESS_TYPES = ["gh_read", "gh_sum"]
+        # gh_sum/min/max for scalars is restricted to iterates_over == 'dof'
+        LFRicConstants.VALID_SCALAR_ACCESS_TYPES = ["gh_read", "gh_sum",
+                                                    "gh_min", "gh_max"]
         LFRicConstants.VALID_ARRAY_ACCESS_TYPES = ["gh_read"]
         LFRicConstants.VALID_FIELD_ACCESS_TYPES = [
             "gh_read", "gh_write", "gh_readwrite", "gh_inc", "gh_readinc"]
@@ -125,7 +126,8 @@ def __init__(self) -> None:
             "gh_read", "gh_write", "gh_readwrite", "gh_inc", "gh_readinc"]
 
         LFRicConstants.WRITE_ACCESSES = [
-            "gh_write", "gh_readwrite", "gh_inc", "gh_readinc", "gh_sum"]
+            "gh_write", "gh_readwrite", "gh_inc", "gh_readinc", "gh_sum",
+            "gh_min", "gh_max"]
 
         # Supported LFRic API stencil types and directions
         LFRicConstants.VALID_STENCIL_TYPES = ["x1d", "y1d", "xory1d", "cross",

src/psyclone/domain/lfric/lfric_invoke.py

@@ -65,7 +65,8 @@ class LFRicInvoke(Invoke):
 
     :raises GenerationError: if integer reductions are required in the
                     PSy-layer.
-
+    :raises GenerationError: if a global reduction operation other than sum
+                             is required - TODO #2381.
     '''
     # pylint: disable=too-many-instance-attributes
     # pylint: disable=too-many-locals
@@ -185,6 +186,10 @@ def __init__(self, alg_invocation, idx, invokes):
                         arg_types=const.VALID_SCALAR_NAMES,
                         arg_accesses=AccessType.get_valid_reduction_modes(),
                         unique=True):
+                    if scalar.access != AccessType.SUM:
+                        raise GenerationError(
+                            "TODO #2381 - currently only global *sum* "
+                            "reductions are supported.")
                     global_sum = LFRicGlobalSum(scalar, parent=loop.parent)
                     loop.parent.children.insert(loop.position+1, global_sum)
 

src/psyclone/parse/lfric_builtins_mod.f90

@@ -672,6 +672,32 @@ module lfric_builtins_mod
      procedure, nopass :: inc_min_aX_code
   end type inc_min_aX
 
+! ------------------------------------------------------------------- !
+! ============ Minimum, maximum value of real field elements) ======= !
+! ------------------------------------------------------------------- !
+
+  type, public, extends(kernel_type) :: minval_X
+     private
+     type(arg_type) :: meta_args(2) = (/                              &
+          arg_type(GH_SCALAR, GH_REAL, GH_MIN               ),        &
+          arg_type(GH_FIELD,  GH_REAL, GH_READ,  ANY_SPACE_1)         &
+          /)
+     integer :: operates_on = DOF
+   contains
+     procedure, nopass :: minval_X_code
+  end type minval_X
+
+  type, public, extends(kernel_type) :: maxval_X
+     private
+     type(arg_type) :: meta_args(2) = (/                              &
+          arg_type(GH_SCALAR, GH_REAL, GH_MAX               ),        &
+          arg_type(GH_FIELD,  GH_REAL, GH_READ,  ANY_SPACE_1)         &
+          /)
+     integer :: operates_on = DOF
+   contains
+     procedure, nopass :: maxval_X_code
+  end type maxval_X
+
 ! ------------------------------------------------------------------- !
 ! ============== Converting real to integer field elements ========== !
 ! ------------------------------------------------------------------- !
@@ -1169,6 +1195,13 @@ end subroutine min_aX_code
   subroutine inc_min_aX_code()
   end subroutine inc_min_aX_code
 
+  ! Minimum and maximum values contained within a field
+  subroutine minval_X_code()
+  end subroutine minval_X_code
+
+  subroutine maxval_X_code()
+  end subroutine maxval_X_code
+
   ! Converting real to integer field elements
   subroutine real_to_int_X_code()
   end subroutine real_to_int_X_code

src/psyclone/psyir/tools/reduction_inference.py

@@ -62,17 +62,18 @@ def _get_reduction_operator(self, node: Node) -> \
             Union[BinaryOperation.Operator, IntrinsicCall.Intrinsic]:
         '''
         :param node: the node to match against.
+
         :returns: the reduction operator at the root of the given
-        DataNode or None if there isn't one.
+                  DataNode or None if there isn't one.
         '''
         if isinstance(node, BinaryOperation):
-            for op in self.red_ops:
-                if node.operator == op:
-                    return node.operator
+            if node.operator in self.red_ops:
+                return node.operator
+
         if isinstance(node, IntrinsicCall):
-            for op in self.red_ops:
-                if node.intrinsic == op:
-                    return node.intrinsic
+            if node.intrinsic in self.red_ops:
+                return node.intrinsic
+
         return None
 
     @staticmethod

src/psyclone/tests/conftest.py

@@ -102,6 +102,9 @@ def setup_psyclone_config():
     independent of a potential psyclone config file installed by
     the user.
     '''
+    # Ensure any Config object that has already been loaded is wiped.
+    Config._instance = None
+
     config_file = Config.get_repository_config_file()
 
     # In case that PSyclone is installed and tested (e.g. GitHub Actions),

src/psyclone/tests/core/access_type_test.py

@@ -72,14 +72,18 @@ def test_api_specific_name():
     assert AccessType.INQUIRY.api_specific_name() == "inquiry"
     assert AccessType.CONSTANT.api_specific_name() == "constant"
     assert AccessType.UNKNOWN.api_specific_name() == "unknown"
-    assert AccessType.get_valid_reduction_modes() == [AccessType.SUM]
-    assert AccessType.get_valid_reduction_names() == ["gh_sum"]
+    assert (set(AccessType.get_valid_reduction_modes()) ==
+            set([AccessType.SUM, AccessType.MIN, AccessType.MAX]))
+    assert (set(AccessType.get_valid_reduction_names()) ==
+            set(["gh_sum", "gh_min", "gh_max"]))
     # Use set to make this independent of the order:
     assert set(AccessType.all_write_accesses()) == set([AccessType.WRITE,
                                                         AccessType.READWRITE,
                                                         AccessType.INC,
                                                         AccessType.READINC,
-                                                        AccessType.SUM])
+                                                        AccessType.SUM,
+                                                        AccessType.MAX,
+                                                        AccessType.MIN])
     assert set(AccessType.all_read_accesses()) == set([AccessType.READ,
                                                        AccessType.READWRITE,
                                                        AccessType.READINC,
@@ -112,7 +116,7 @@ def test_all_write_accesses():
 
     all_write_accesses = AccessType.all_write_accesses()
     assert isinstance(all_write_accesses, list)
-    assert len(all_write_accesses) == 5
+    assert len(all_write_accesses) == 7
     assert (len(all_write_accesses) ==
             len(set(all_write_accesses)))
     assert all(isinstance(write_access, AccessType)

src/psyclone/tests/domain/lfric/kernel/evaluator_targets_metadata_test.py

@@ -40,6 +40,7 @@
 
 from fparser.two import Fortran2003
 
+from psyclone.domain.lfric import LFRicConstants
 from psyclone.domain.lfric.kernel import EvaluatorTargetsMetadata
 
 
@@ -145,7 +146,7 @@ def test_setter_errors():
 
     with pytest.raises(ValueError) as info:
         metadata.evaluator_targets = ["invalid"]
-    assert ("The 'evaluator_targets' metadata should be a recognised value "
-            "(one of ['w3', 'wtheta', 'w2v', 'w2vtrace', 'w2broken', 'w0', "
-            "'w1', 'w2', 'w2trace', 'w2h', 'w2htrace', 'any_w2', 'wchi']) "
-            "but found 'invalid'." in str(info.value))
+    const = LFRicConstants()
+    assert (f"The 'evaluator_targets' metadata should be a recognised value "
+            f"(one of {const.VALID_FUNCTION_SPACES}) but found "
+            f"'invalid'." in str(info.value))