Inheritance diagram for psyclone.dynamo0p3.LFRicHaloExchange:

[legend]

Collaboration diagram for psyclone.dynamo0p3.LFRicHaloExchange:

Public Member Functions
def	__init__ (self, field, check_dirty=True, vector_index=None, parent=None)

def	required (self, ignore_hex_dep=False)

def	node_str (self, colour=True)

def	gen_code (self, parent)

def	lower_to_language_level (self)

Public Member Functions inherited from psyclone.psyGen.HaloExchange
def	vector_index (self)

def	halo_depth (self)

def	halo_depth (self, value)

def	field (self)

def	dag_name (self)

def	args (self)

def	check_vector_halos_differ (self, node)

Additional Inherited Members
Public Attributes inherited from psyclone.psyGen.HaloExchange
	vector_index

Detailed Description

Dynamo specific halo exchange class which can be added to and
manipulated in a schedule.

:param field: the field that this halo exchange will act on
:type field: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param check_dirty: optional argument default True indicating \
whether this halo exchange should be subject to a run-time check \
for clean/dirty halos.
:type check_dirty: bool
:param vector_index: optional vector index (default None) to \
identify which index of a vector field this halo exchange is \
responsible for
:type vector_index: int
:param parent: optional PSyIRe parent node (default None) of this \
object
:type parent: :py:class:`psyclone.psyir.nodes.Node`

Definition at line 3796 of file dynamo0p3.py.

Member Function Documentation

◆ gen_code()

def psyclone.dynamo0p3.LFRicHaloExchange.gen_code	(	self,
		parent
	)

Dynamo specific code generation for this class.

:param parent: an f2pygen object that will be the parent of \
f2pygen objects created in this method
:type parent: :py:class:`psyclone.f2pygen.BaseGen`

Definition at line 4197 of file dynamo0p3.py.

     def gen_code(self, parent):
         '''Dynamo specific code generation for this class.
  
         :param parent: an f2pygen object that will be the parent of \
         f2pygen objects created in this method
         :type parent: :py:class:`psyclone.f2pygen.BaseGen`
  
         '''
         parent.add(PSyIRGen(parent, self))
  

Here is the caller graph for this function:

◆ lower_to_language_level()

def psyclone.dynamo0p3.LFRicHaloExchange.lower_to_language_level ( self )

:returns: this node lowered to language-level PSyIR.
:rtype: :py:class:`psyclone.psyir.nodes.Node`

Definition at line 4207 of file dynamo0p3.py.

     def lower_to_language_level(self):
         '''
         :returns: this node lowered to language-level PSyIR.
         :rtype: :py:class:`psyclone.psyir.nodes.Node`
         '''
         symbol = DataSymbol(self._field.proxy_name, UnresolvedType())
         method = self._halo_exchange_name
         depth_expr = self._psyir_depth_expression()
  
         # Create infrastructure Calls
         if self.vector_index:
             idx = Literal(str(self.vector_index), INTEGER_TYPE)
             if_condition = Call.create(
                 ArrayOfStructuresReference.create(symbol, [idx], ['is_dirty']),
                 [('depth', depth_expr)])
             if_body = Call.create(
                 ArrayOfStructuresReference.create(
                     symbol, [idx.copy()], [method]),
                 [('depth', depth_expr.copy())])
         else:
             if_condition = Call.create(
                 StructureReference.create(symbol, ['is_dirty']),
                 [('depth', depth_expr)])
             if_body = Call.create(
                 StructureReference.create(symbol, [method]),
                 [('depth', depth_expr.copy())])
  
         # Add the "if_dirty" check when necessary
         _, known = self.required()
         if not known:
             haloex = IfBlock.create(if_condition, [if_body])
         else:
             haloex = if_body
  
         self.replace_with(haloex)
         return haloex
  
  

References psyclone.domain.common.psylayer.psyloop.PSyLoop._field, psyclone.domain.lfric.arg_index_to_metadata_index.ArgIndexToMetadataIndex._field(), psyclone.domain.lfric.lfric_loop.LFRicLoop._field, psyclone.domain.lfric.metadata_to_arguments_rules.MetadataToArgumentsRules._field(), psyclone.psyGen.HaloExchange._field, psyclone.dynamo0p3.LFRicHaloExchange._halo_exchange_name, psyclone.dynamo0p3.LFRicHaloExchangeStart._halo_exchange_name, psyclone.dynamo0p3.LFRicHaloExchangeEnd._halo_exchange_name, psyclone.gocean1p0.GOHaloExchange._halo_exchange_name, psyclone.dynamo0p3.LFRicHaloExchange._psyir_depth_expression(), psyclone.dynamo0p3.LFRicHaloExchangeStart._psyir_depth_expression(), psyclone.psyir.nodes.node.Node.replace_with(), psyclone.dynamo0p3.LFRicHaloExchangeStart.required(), psyclone.dynamo0p3.LFRicHaloExchange.required(), and psyclone.psyGen.HaloExchange.vector_index.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ node_str()

def psyclone.dynamo0p3.LFRicHaloExchange.node_str	(	self,
		colour = `True`
	)

 Creates a text summary of this HaloExchange node.

:param bool colour: whether or not to include control codes for colour.

:returns: text summary of this node, optionally with control codes \
          for colour highlighting.
:rtype: str

Reimplemented from psyclone.psyGen.HaloExchange.

Definition at line 4177 of file dynamo0p3.py.

     def node_str(self, colour=True):
         ''' Creates a text summary of this HaloExchange node.
  
         :param bool colour: whether or not to include control codes for colour.
  
         :returns: text summary of this node, optionally with control codes \
                   for colour highlighting.
         :rtype: str
  
         '''
         _, known = self.required()
         runtime_check = not known
         field_id = self._field.name
         if self.vector_index:
             field_id += f"({self.vector_index})"
         return (f"{self.coloured_name(colour)}[field='{field_id}', "
                 f"type='{self._compute_stencil_type()}', "
                 f"depth={self._compute_halo_depth()}, "
                 f"check_dirty={runtime_check}]")
  

References psyclone.domain.common.psylayer.psyloop.PSyLoop._field, psyclone.domain.lfric.arg_index_to_metadata_index.ArgIndexToMetadataIndex._field(), psyclone.domain.lfric.lfric_loop.LFRicLoop._field, psyclone.domain.lfric.metadata_to_arguments_rules.MetadataToArgumentsRules._field(), psyclone.psyGen.HaloExchange._field, psyclone.dynamo0p3.LFRicHaloExchangeStart.required(), psyclone.dynamo0p3.LFRicHaloExchange.required(), and psyclone.psyGen.HaloExchange.vector_index.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ required()

def psyclone.dynamo0p3.LFRicHaloExchange.required	(	self,
		ignore_hex_dep = `False`
	)

Determines whether this halo exchange is definitely required
``(True, True)``, might be required ``(True, False)`` or is definitely
not required ``(False, *)``.

If the optional ignore_hex_dep argument is set to True then
any read accesses contained in halo exchange nodes are
ignored. This option can therefore be used to filter out any
halo exchange dependencies and only consider non-halo exchange
dependencies if and when required.

Whilst a halo exchange is generally only ever added if it is
required, or if it may be required, this situation can change
if redundant computation transformations are applied. The
first argument can be used to remove such halo exchanges if
required.

When the first return value is True, the second return value
can be used to see if we need to rely on the runtime
(set_dirty and set_clean calls) and therefore add a
check_dirty() call around the halo exchange or whether we
definitely know that this halo exchange is required.

This routine assumes that a stencil size provided via a
variable may take the value 0. If a variables value is
constrained to be 1, or more, then the logic for deciding
whether a halo exchange is definitely required should be
updated. Note, the routine would still be correct as is, it
would just return more unknown results than it should).

:param bool ignore_hex_dep: if True then ignore any read \
    accesses contained in halo exchanges. This is an optional \
    argument that defaults to False.

:returns: (x, y) where x specifies whether this halo \
    exchange is (or might be) required - True, or is not \
    required - False. If the first tuple item is True then the \
    second argument specifies whether we definitely know that \
    we need the HaloExchange - True, or are not sure - False.
:rtype: (bool, bool)

Definition at line 4002 of file dynamo0p3.py.

     def required(self, ignore_hex_dep=False):
         '''Determines whether this halo exchange is definitely required
         ``(True, True)``, might be required ``(True, False)`` or is definitely
         not required ``(False, *)``.
  
         If the optional ignore_hex_dep argument is set to True then
         any read accesses contained in halo exchange nodes are
         ignored. This option can therefore be used to filter out any
         halo exchange dependencies and only consider non-halo exchange
         dependencies if and when required.
  
         Whilst a halo exchange is generally only ever added if it is
         required, or if it may be required, this situation can change
         if redundant computation transformations are applied. The
         first argument can be used to remove such halo exchanges if
         required.
  
         When the first return value is True, the second return value
         can be used to see if we need to rely on the runtime
         (set_dirty and set_clean calls) and therefore add a
         check_dirty() call around the halo exchange or whether we
         definitely know that this halo exchange is required.
  
         This routine assumes that a stencil size provided via a
         variable may take the value 0. If a variables value is
         constrained to be 1, or more, then the logic for deciding
         whether a halo exchange is definitely required should be
         updated. Note, the routine would still be correct as is, it
         would just return more unknown results than it should).
  
         :param bool ignore_hex_dep: if True then ignore any read \
             accesses contained in halo exchanges. This is an optional \
             argument that defaults to False.
  
         :returns: (x, y) where x specifies whether this halo \
             exchange is (or might be) required - True, or is not \
             required - False. If the first tuple item is True then the \
             second argument specifies whether we definitely know that \
             we need the HaloExchange - True, or are not sure - False.
         :rtype: (bool, bool)
  
         '''
         # pylint: disable=too-many-branches, too-many-return-statements
         # get *aggregated* information about halo reads
         required_clean_info = self._compute_halo_read_depth_info(
             ignore_hex_dep)
         # get information about the halo write
         clean_info = self._compute_halo_write_info()
  
         # no need to test whether we return at least one read
         # dependency as _compute_halo_read_depth_info() raises an
         # exception if none are found
  
         if Config.get().api_conf("dynamo0.3").compute_annexed_dofs and \
            len(required_clean_info) == 1 and \
            required_clean_info[0].annexed_only:
             # We definitely don't need the halo exchange as we
             # only read annexed dofs and these are always clean as
             # they are computed by default when iterating over
             # dofs and kept up-to-date by redundant computation
             # when iterating over cells.
             required = False
             known = True  # redundant information as it is always known
             return required, known
  
         if not clean_info:
             # this halo exchange has no previous write dependencies so
             # we do not know the initial state of the halo. This means
             # that we do not know if we need a halo exchange or not
             required = True
             known = False
             return required, known
  
         if clean_info.max_depth:
             if not clean_info.dirty_outer:
                 # all of the halo is cleaned by redundant computation
                 # so halo exchange is not required
                 required = False
                 known = True  # redundant information as it is always known
             else:
                 # the last level halo is dirty
                 if required_clean_info[0].max_depth:
                     # we know that we need to clean the outermost halo level
                     required = True
                     known = True
                 else:
                     # we don't know whether the halo exchange is
                     # required or not as the reader reads the halo to
                     # a specified depth but we don't know the depth
                     # of the halo
                     required = True
                     known = False
             return required, known
  
         # at this point we know that clean_info.max_depth is False
  
         if not clean_info.literal_depth:
             # if literal_depth is 0 then the writer does not
             # redundantly compute so we definitely need the halo
             # exchange
             required = True
             known = True
             return required, known
  
         if clean_info.literal_depth == 1 and clean_info.dirty_outer:
             # the writer redundantly computes in the level 1 halo but
             # leaves it dirty (although annexed dofs are now clean).
             if len(required_clean_info) == 1 and \
                required_clean_info[0].annexed_only:
                 # we definitely don't need the halo exchange as we
                 # only read annexed dofs and these have been made
                 # clean by the redundant computation
                 required = False
                 known = True  # redundant information as it is always known
             else:
                 # we definitely need the halo exchange as the reader(s)
                 # require the halo to be clean
                 required = True
                 known = True
             return required, known
  
         # At this point we know that the writer cleans the halo to a
         # known (literal) depth through redundant computation. We now
         # compute this value for use by the logic in the rest of the
         # routine.
         clean_depth = clean_info.literal_depth
         if clean_info.dirty_outer:
             # outer layer stays dirty
             clean_depth -= 1
  
         # If a literal value in any of the required clean halo depths
         # is greater than the cleaned depth then we definitely need
         # the halo exchange (as any additional variable depth would
         # increase the required depth value). We only look at the case
         # where we have multiple entries as the single entry case is
         # dealt with separately
         if len(required_clean_info) > 1:
             for required_clean in required_clean_info:
                 if required_clean.literal_depth > clean_depth:
                     required = True
                     known = True
                     return required, known
  
         # The only other case where we know that a halo exchange is
         # required (or not) is where we read the halo to a known
         # literal depth. As the read information is aggregated, a known
         # literal depth will mean that there is only one
         # required_clean_info entry
         if len(required_clean_info) == 1:
             # the halo might be read to a fixed literal depth
             if required_clean_info[0].var_depth or \
                required_clean_info[0].max_depth:
                 # no it isn't so we might need the halo exchange
                 required = True
                 known = False
             else:
                 # the halo is read to a fixed literal depth.
                 required_clean_depth = required_clean_info[0].literal_depth
                 if clean_depth < required_clean_depth:
                     # we definitely need this halo exchange
                     required = True
                     known = True
                 else:
                     # we definitely don't need this halo exchange
                     required = False
                     known = True  # redundant information as it is always known
             return required, known
  
         # We now know that at least one required_clean entry has a
         # variable depth and any required_clean fixed depths are less
         # than the cleaned depth so we may need a halo exchange.
         required = True
         known = False
         return required, known
  

References psyclone.dynamo0p3.LFRicHaloExchange._compute_halo_read_depth_info(), and psyclone.dynamo0p3.LFRicHaloExchange._compute_halo_write_info().

Here is the call graph for this function:

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/dynamo0p3.py

Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ gen_code()

◆ lower_to_language_level()

◆ node_str()

◆ required()