Inheritance diagram for psyclone.transformations.Dynamo0p3RedundantComputationTrans:

[legend]

Collaboration diagram for psyclone.transformations.Dynamo0p3RedundantComputationTrans:

[legend]

Public Member Functions
def	__str__ (self)

def	validate (self, node, options=None)

def	apply (self, loop, options=None)

Public Member Functions inherited from psyclone.psyir.transformations.loop_trans.LoopTrans
def	name (self)

Additional Inherited Members
Static Public Attributes inherited from psyclone.psyir.transformations.loop_trans.LoopTrans
tuple	excluded_node_types = ()

Detailed Description

This transformation allows the user to modify a loop's bounds so
that redundant computation will be performed. Redundant
computation can result in halo exchanges being modified, new halo
exchanges being added or existing halo exchanges being removed.

* This transformation should be performed before any
  parallelisation transformations (e.g. for OpenMP) to the loop in
  question and will raise an exception if this is not the case.

* This transformation can not be applied to a loop containing a
  reduction and will again raise an exception if this is the case.

* This transformation can only be used to add redundant
  computation to a loop, not to remove it.

* This transformation allows a loop that is already performing
  redundant computation to be modified, but only if the depth is
  increased.

Definition at line 1768 of file transformations.py.

Member Function Documentation

◆ apply()

def psyclone.transformations.Dynamo0p3RedundantComputationTrans.apply	(	self,
		loop,
		options = `None`
	)

Apply the redundant computation transformation to the loop
:py:obj:`loop`. This transformation can be applied to loops iterating
over 'cells or 'dofs'. if :py:obj:`depth` is set to a value then the
value will be the depth of the field's halo over which redundant
computation will be performed. If :py:obj:`depth` is not set to a
value then redundant computation will be performed to the full depth
of the field's halo.

:param loop: the loop that we are transforming.
:type loop: :py:class:`psyclone.psyGen.LFRicLoop`
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]
:param int options["depth"]: the depth of the stencil. Defaults \
        to None.

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 1951 of file transformations.py.

     def apply(self, loop, options=None):
         # pylint:disable=arguments-renamed
         '''Apply the redundant computation transformation to the loop
         :py:obj:`loop`. This transformation can be applied to loops iterating
         over 'cells or 'dofs'. if :py:obj:`depth` is set to a value then the
         value will be the depth of the field's halo over which redundant
         computation will be performed. If :py:obj:`depth` is not set to a
         value then redundant computation will be performed to the full depth
         of the field's halo.
  
         :param loop: the loop that we are transforming.
         :type loop: :py:class:`psyclone.psyGen.LFRicLoop`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
         :param int options["depth"]: the depth of the stencil. Defaults \
                 to None.
  
         '''
         self.validate(loop, options=options)
         if not options:
             options = {}
         depth = options.get("depth")
  
         if loop.loop_type == "":
             # Loop is over cells
             loop.set_upper_bound("cell_halo", depth)
         elif loop.loop_type == "colour":
             # Loop is over cells of a single colour
             loop.set_upper_bound("colour_halo", depth)
         elif loop.loop_type == "dof":
             loop.set_upper_bound("dof_halo", depth)
         else:
             raise TransformationError(
                 f"Unsupported loop_type '{loop.loop_type}' found in "
                 f"Dynamo0p3Redundant ComputationTrans.apply()")
         # Add/remove halo exchanges as required due to the redundant
         # computation
         loop.update_halo_exchanges()
  
  

Here is the call graph for this function:

◆ validate()

def psyclone.transformations.Dynamo0p3RedundantComputationTrans.validate	(	self,
		node,
		options = `None`
	)

Perform various checks to ensure that it is valid to apply the
RedundantComputation transformation to the supplied node

:param node: the supplied node on which we are performing\
             validity checks
:type node: :py:class:`psyclone.psyir.nodes.Node`
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]
:param int options["depth"]: the depth of the stencil if the value \
             is provided and None if not.

:raises TransformationError: if the parent of the loop is a\
    :py:class:`psyclone.psyir.nodes.Directive`.
:raises TransformationError: if the parent of the loop is not a\
    :py:class:`psyclone.psyir.nodes.Loop` or a\
    :py:class:`psyclone.psyGen.LFRicInvokeSchedule`.
:raises TransformationError: if the parent of the loop is a\
    :py:class:`psyclone.psyir.nodes.Loop` but the original loop does\
    not iterate over 'colour'.
:raises TransformationError: if the parent of the loop is a\
    :py:class:`psyclone.psyir.nodes.Loop` but the parent does not
    iterate over 'colours'.
:raises TransformationError: if the parent of the loop is a\
    :py:class:`psyclone.psyir.nodes.Loop` but the parent's parent is\
    not a :py:class:`psyclone.psyGen.LFRicInvokeSchedule`.
:raises TransformationError: if this transformation is applied\
    when distributed memory is not switched on.
:raises TransformationError: if the loop does not iterate over\
    cells, dofs or colour.
:raises TransformationError: if the transformation is setting the\
    loop to the maximum halo depth but the loop already computes\
    to the maximum halo depth.
:raises TransformationError: if the transformation is setting the\
    loop to the maximum halo depth but the loop contains a stencil\
    access (as this would result in the field being accessed\
    beyond the halo depth).
:raises TransformationError: if the supplied depth value is not an\
    integer.
:raises TransformationError: if the supplied depth value is less\
    than 1.
:raises TransformationError: if the supplied depth value is not\
    greater than 1 when a continuous loop is modified as this is\
    the minimum valid value.
:raises TransformationError: if the supplied depth value is not\
    greater than the existing depth value, as we should not need\
    to undo existing transformations.
:raises TransformationError: if a depth value has been supplied\
    but the loop has already been set to the maximum halo depth.

Reimplemented from psyclone.psyir.transformations.loop_trans.LoopTrans.

Definition at line 1792 of file transformations.py.

     def validate(self, node, options=None):
         '''Perform various checks to ensure that it is valid to apply the
         RedundantComputation transformation to the supplied node
  
         :param node: the supplied node on which we are performing\
                      validity checks
         :type node: :py:class:`psyclone.psyir.nodes.Node`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
         :param int options["depth"]: the depth of the stencil if the value \
                      is provided and None if not.
  
         :raises TransformationError: if the parent of the loop is a\
             :py:class:`psyclone.psyir.nodes.Directive`.
         :raises TransformationError: if the parent of the loop is not a\
             :py:class:`psyclone.psyir.nodes.Loop` or a\
             :py:class:`psyclone.psyGen.LFRicInvokeSchedule`.
         :raises TransformationError: if the parent of the loop is a\
             :py:class:`psyclone.psyir.nodes.Loop` but the original loop does\
             not iterate over 'colour'.
         :raises TransformationError: if the parent of the loop is a\
             :py:class:`psyclone.psyir.nodes.Loop` but the parent does not
             iterate over 'colours'.
         :raises TransformationError: if the parent of the loop is a\
             :py:class:`psyclone.psyir.nodes.Loop` but the parent's parent is\
             not a :py:class:`psyclone.psyGen.LFRicInvokeSchedule`.
         :raises TransformationError: if this transformation is applied\
             when distributed memory is not switched on.
         :raises TransformationError: if the loop does not iterate over\
             cells, dofs or colour.
         :raises TransformationError: if the transformation is setting the\
             loop to the maximum halo depth but the loop already computes\
             to the maximum halo depth.
         :raises TransformationError: if the transformation is setting the\
             loop to the maximum halo depth but the loop contains a stencil\
             access (as this would result in the field being accessed\
             beyond the halo depth).
         :raises TransformationError: if the supplied depth value is not an\
             integer.
         :raises TransformationError: if the supplied depth value is less\
             than 1.
         :raises TransformationError: if the supplied depth value is not\
             greater than 1 when a continuous loop is modified as this is\
             the minimum valid value.
         :raises TransformationError: if the supplied depth value is not\
             greater than the existing depth value, as we should not need\
             to undo existing transformations.
         :raises TransformationError: if a depth value has been supplied\
             but the loop has already been set to the maximum halo depth.
  
         '''
         # pylint: disable=too-many-branches
         # check node is a loop
         super().validate(node, options=options)
  
         # Check loop's parent is the InvokeSchedule, or that it is nested
         # in a colours loop and perform other colour(s) loop checks,
         # otherwise halo exchange placement might fail. The only
         # current example where the placement would fail is when
         # directives have already been added. This could be fixed but
         # it actually makes sense to require redundant computation
         # transformations to be applied before adding directives so it
         # is not particularly important.
         dir_node = node.ancestor(Directive)
         if dir_node:
             raise TransformationError(
                 f"In the Dynamo0p3RedundantComputation transformation apply "
                 f"method the supplied loop is sits beneath a directive of "
                 f"type {type(dir_node)}. Redundant computation must be applied"
                 f" before directives are added.")
         if not (isinstance(node.parent, LFRicInvokeSchedule) or
                 isinstance(node.parent.parent, Loop)):
             raise TransformationError(
                 f"In the Dynamo0p3RedundantComputation transformation "
                 f"apply method the parent of the supplied loop must be the "
                 f"LFRicInvokeSchedule, or a Loop, but found "
                 f"{type(node.parent)}")
         if isinstance(node.parent.parent, Loop):
             if node.loop_type != "colour":
                 raise TransformationError(
                     f"In the Dynamo0p3RedundantComputation transformation "
                     f"apply method, if the parent of the supplied Loop is "
                     f"also a Loop then the supplied Loop must iterate over "
                     f"'colour', but found '{node.loop_type}'")
             if node.parent.parent.loop_type != "colours":
                 raise TransformationError(
                     f"In the Dynamo0p3RedundantComputation transformation "
                     f"apply method, if the parent of the supplied Loop is "
                     f"also a Loop then the parent must iterate over "
                     f"'colours', but found '{node.parent.parent.loop_type}'")
             if not isinstance(node.parent.parent.parent, LFRicInvokeSchedule):
                 raise TransformationError(
                     f"In the Dynamo0p3RedundantComputation transformation "
                     f"apply method, if the parent of the supplied Loop is "
                     f"also a Loop then the parent's parent must be the "
                     f"LFRicInvokeSchedule, but found {type(node.parent)}")
         if not Config.get().distributed_memory:
             raise TransformationError(
                 "In the Dynamo0p3RedundantComputation transformation apply "
                 "method distributed memory must be switched on")
  
         # loop must iterate over cell-column, dof or colour. Note, an
         # empty loop_type iterates over cell-columns.
         if node.loop_type not in ["", "dof", "colour"]:
             raise TransformationError(
                 f"In the Dynamo0p3RedundantComputation transformation apply "
                 f"method the loop type must be one of '' (cell-columns), 'dof'"
                 f" or 'colour', but found '{node.loop_type}'")
  
         # We don't currently support the application of transformations to
         # loops containing inter-grid kernels
         check_intergrid(node)
         const = LFRicConstants()
  
         if not options:
             options = {}
         depth = options.get("depth")
         if depth is None:
             if node.upper_bound_name in const.HALO_ACCESS_LOOP_BOUNDS:
                 if not node.upper_bound_halo_depth:
                     raise TransformationError(
                         "In the Dynamo0p3RedundantComputation transformation "
                         "apply method the loop is already set to the maximum "
                         "halo depth so this transformation does nothing")
                 for call in node.kernels():
                     for arg in call.arguments.args:
                         if arg.stencil:
                             raise TransformationError(
                                 f"In the Dynamo0p3RedundantComputation "
                                 f"transformation apply method the loop "
                                 f"contains field '{arg.name}' with a stencil "
                                 f"access in kernel '{call.name}', so it is "
                                 f"invalid to set redundant computation to "
                                 f"maximum depth")
         else:
             if not isinstance(depth, int):
                 raise TransformationError(
                     f"In the Dynamo0p3RedundantComputation transformation "
                     f"apply method the supplied depth should be an integer but"
                     f" found type '{type(depth)}'")
             if depth < 1:
                 raise TransformationError(
                     "In the Dynamo0p3RedundantComputation transformation "
                     "apply method the supplied depth is less than 1")
  
             if node.upper_bound_name in const.HALO_ACCESS_LOOP_BOUNDS:
                 if node.upper_bound_halo_depth:
                     if node.upper_bound_halo_depth >= depth:
                         raise TransformationError(
                             f"In the Dynamo0p3RedundantComputation "
                             f"transformation apply method the supplied depth "
                             f"({depth}) must be greater than the existing halo"
                             f" depth ({node.upper_bound_halo_depth})")
                 else:
                     raise TransformationError(
                         "In the Dynamo0p3RedundantComputation transformation "
                         "apply method the loop is already set to the maximum "
                         "halo depth so can't be set to a fixed value")
  

Here is the caller graph for this function:

The documentation for this class was generated from the following file:

/home/docs/checkouts/readthedocs.org/user_builds/psyclone-ref/checkouts/latest/src/psyclone/transformations.py

Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ apply()

◆ validate()