Inheritance diagram for psyclone.gocean1p0.GOLoop:

Collaboration diagram for psyclone.gocean1p0.GOLoop:

Public Member Functions
def	__init__ (self, parent, loop_type="", field_name="", field_space="", iteration_space="", index_offset="")

def	field_space (self)

def	field_space (self, my_field_space)

def	iteration_space (self)

def	iteration_space (self, it_space)

def	bounds_lookup (self)

def	independent_iterations (self, test_all_variables=False, signatures_to_ignore=None, dep_tools=None)

def	create_halo_exchanges (self)

def	get_custom_bound_string (self, side)

def	upper_bound (self)

def	lower_bound (self)

def	gen_code (self, parent)

Public Member Functions inherited from psyclone.domain.common.psylayer.psyloop.PSyLoop
def	__init__ (self, valid_loop_types=None, **kwargs)

def	__eq__ (self, other)

def	dag_name (self)

def	valid_loop_types (self)

def	loop_type (self)

def	loop_type (self, value)

def	node_str (self, colour=True)

def	field_name (self)

def	field (self)

def	field_name (self, my_field_name)

def	kernel (self)

def	kernel (self, kern)

def	__str__ (self)

def	has_inc_arg (self)

def	unique_modified_args (self, arg_type)

def	unique_fields_with_halo_reads (self)

def	args_filter (self, arg_types=None, arg_accesses=None, unique=False)

def	gen_mark_halos_clean_dirty (self, parent)

Static Public Member Functions
def	create (parent, loop_type, field_name="", field_space="", iteration_space="", index_offset="")

def	setup_bounds ()

def	add_bounds (bound_info)

Public Attributes
	loop_type

	field_name

	field_space

	iteration_space

	index_offset

	variable

Public Attributes inherited from psyclone.domain.common.psylayer.psyloop.PSyLoop
	loop_type

	field

	field_name

	field_space

	iteration_space

	kernel

Detailed Description

 The GOcean specific PSyLoop class. This passes the GOcean specific
    single loop information to the base class so it creates the one we
    require. Adds a GOcean specific setBounds method which tells the loop
    what to iterate over. Need to harmonise with the topology_name method
    in the Dynamo api.

    :param parent: optional parent node (default None).
    :type parent: :py:class:`psyclone.psyir.nodes.Node`
    :param str loop_type: loop type - must be 'inner' or 'outer'.
    :param str field_name: name of the field this loop iterates on.
    :param str field_space: space of the field this loop iterates on.
    :param str iteration_space: iteration space of the loop.

    :raises GenerationError: if the loop is not inserted inside a \
        GOInvokeSchedule region.

Definition at line 331 of file gocean1p0.py.

Member Function Documentation

◆ add_bounds()

def psyclone.gocean1p0.GOLoop.add_bounds ( bound_info )

static

Adds a new iteration space to PSyclone. An iteration space in the
gocean1.0 API is for a certain offset type and field type. It defines
the loop boundaries for the outer and inner loop. The format is a
":" separated tuple:

>>> bound_info = offset-type:field-type:iteration-space:outer-start:
                 outer-stop:inner-start:inner-stop

Example:

>>> bound_info = go_offset_ne:go_ct:go_all_pts:
                 {start}-1:{stop}+1:{start}:{stop}

The expressions {start} and {stop} will be replaced with the loop
indices that correspond to the inner points (i.e. non-halo or
boundary points) of the field. So the index {start}-1 is actually
on the halo / boundary.

:param str bound_info: A string that contains a ":" separated \
                       tuple with the iteration space definition.

:raises ValueError: if bound_info is not a string.
:raises ConfigurationError: if bound_info is not formatted correctly.

Definition at line 696 of file gocean1p0.py.

     def add_bounds(bound_info):
         # pylint: disable=too-many-locals
         '''
         Adds a new iteration space to PSyclone. An iteration space in the
         gocean1.0 API is for a certain offset type and field type. It defines
         the loop boundaries for the outer and inner loop. The format is a
         ":" separated tuple:
  
         >>> bound_info = offset-type:field-type:iteration-space:outer-start:
                          outer-stop:inner-start:inner-stop
  
         Example:
  
         >>> bound_info = go_offset_ne:go_ct:go_all_pts:
                          {start}-1:{stop}+1:{start}:{stop}
  
         The expressions {start} and {stop} will be replaced with the loop
         indices that correspond to the inner points (i.e. non-halo or
         boundary points) of the field. So the index {start}-1 is actually
         on the halo / boundary.
  
         :param str bound_info: A string that contains a ":" separated \
                                tuple with the iteration space definition.
  
         :raises ValueError: if bound_info is not a string.
         :raises ConfigurationError: if bound_info is not formatted correctly.
  
         '''
         if not isinstance(bound_info, str):
             raise InternalError(f"The parameter 'bound_info' must be a "
                                 f"string, got '{bound_info}' "
                                 f"(type {type(bound_info)})")
  
         data = bound_info.split(":")
         if len(data) != 7:
             raise ConfigurationError(f"An iteration space must be in the form "
                                      f"\"offset-type:field-type:"
                                      f"iteration-space:outer-start:"
                                      f"outer-stop:inner-start:inner-stop\"\n"
                                      f"But got \"{bound_info}\"")
  
         if not GOLoop._bounds_lookup:
             GOLoop.setup_bounds()
  
         # Check that all bound specifications (min and max index) are valid.
         # ------------------------------------------------------------------
         # Regular expression that finds stings surrounded by {}
         bracket_regex = re.compile("{[^}]+}")
         for bound in data[3:7]:
             all_expr = bracket_regex.findall(bound)
             for bracket_expr in all_expr:
                 if bracket_expr not in ["{start}", "{stop}"]:
                     raise ConfigurationError(f"Only '{{start}}' and "
                                              f"'{{stop}}' are allowed as "
                                              f"bracketed expression in an "
                                              f"iteration space. But got "
                                              f"{bracket_expr}")
  
         # We need to make sure the fparser is properly initialised, which
         # typically has not yet happened when the config file is read.
         # Otherwise the Nonlabel_Do_Stmt cannot parse valid expressions.
         ParserFactory().create(std="f2008")
  
         # Test both the outer loop indices (index 3 and 4) and inner
         # indices (index 5 and 6):
         for bound in data[3:7]:
             do_string = f"do i=1, {bound}"
             # Now replace any {start}/{stop} expression in the loop
             # with a valid integer value:
             do_string = do_string.format(start='15', stop='25')
             # Check if the do loop can be parsed as a nonlabel do loop
             try:
                 _ = Nonlabel_Do_Stmt(do_string)
             except NoMatchError as err:
                 raise ConfigurationError(f"Expression '{bound}' is not a "
                                          f"valid do loop boundary. Error "
                                          f"message: '{err}'.") from err
  
         # All tests successful, so add the new bounds:
         # --------------------------------------------
         current_bounds = GOLoop._bounds_lookup   # Shortcut
         # Check offset-type exists
         if not data[0] in current_bounds:
             current_bounds[data[0]] = {}
  
         # Check field-type exists
         if not data[1] in current_bounds[data[0]]:
             current_bounds[data[0]][data[1]] = {}
  
         const = GOceanConstants()
         # Check iteration space exists:
         if not data[2] in current_bounds[data[0]][data[1]]:
             current_bounds[data[0]][data[1]][data[2]] = {}
             const.VALID_ITERATES_OVER.append(data[2])
  
         current_bounds[data[0]][data[1]][data[2]] = \
             {'outer': {'start': data[3], 'stop': data[4]},
              'inner': {'start': data[5], 'stop': data[6]}}
  

References psyclone.gocean1p0.GOLoop.create().

Here is the call graph for this function:

◆ bounds_lookup()

def psyclone.gocean1p0.GOLoop.bounds_lookup ( self )

:returns: the GOcean loop bounds lookup table. This is a \
          5-dimensional dictionary with index-offset, field-space, \
          iteration-space, loop-type, and boundary-side lookup keys \
          which provides information about how to construct the \
          loop boundaries for a kernel with such parameters.
:rtype: dict

Definition at line 506 of file gocean1p0.py.

     def bounds_lookup(self):
         '''
         :returns: the GOcean loop bounds lookup table. This is a \
                   5-dimensional dictionary with index-offset, field-space, \
                   iteration-space, loop-type, and boundary-side lookup keys \
                   which provides information about how to construct the \
                   loop boundaries for a kernel with such parameters.
         :rtype: dict
         '''
         return self._bounds_lookup
  

References psyclone.gocean1p0.GOLoop._bounds_lookup.

Here is the caller graph for this function:

◆ create()

def psyclone.gocean1p0.GOLoop.create	(	parent,
		loop_type,
		field_name = `""`,
		field_space = `""`,
		iteration_space = `""`,
		index_offset = `""`
	)

static

Create a new instance of a GOLoop with the expected children to
represent the bounds given by the loop properties.

:param parent: parent node of this GOLoop.
:type parent: :py:class:`psyclone.psyir.nodes.Node`
:param str loop_type: loop type - must be 'inner' or 'outer'.
:param str field_name: name of the field this loop iterates on.
:param str field_space: space of the field this loop iterates on.
:param str iteration_space: iteration space of the loop.
:param str index_offset: the grid index offset used by the kernel(s) \
    within this loop.

:returns: a new GOLoop node (with appropriate child nodes).
:rtype: :py:class:`psyclone.gocean1p0.GOLoop`

Definition at line 402 of file gocean1p0.py.

                iteration_space="", index_offset=""):
         # pylint: disable=too-many-arguments,arguments-renamed
         '''
         Create a new instance of a GOLoop with the expected children to
         represent the bounds given by the loop properties.
  
         :param parent: parent node of this GOLoop.
         :type parent: :py:class:`psyclone.psyir.nodes.Node`
         :param str loop_type: loop type - must be 'inner' or 'outer'.
         :param str field_name: name of the field this loop iterates on.
         :param str field_space: space of the field this loop iterates on.
         :param str iteration_space: iteration space of the loop.
         :param str index_offset: the grid index offset used by the kernel(s) \
             within this loop.
  
         :returns: a new GOLoop node (with appropriate child nodes).
         :rtype: :py:class:`psyclone.gocean1p0.GOLoop`
         '''
  
         # Create loop node
         node = GOLoop(parent, loop_type, field_name, field_space,
                       iteration_space, index_offset)
  
         # Add start, stop, step and body and Loop children
         node.addchild(node.lower_bound())
         node.addchild(node.upper_bound())
         node.addchild(Literal("1", INTEGER_TYPE))
         node.addchild(Schedule())
  
         return node
  

Here is the caller graph for this function:

◆ create_halo_exchanges()

def psyclone.gocean1p0.GOLoop.create_halo_exchanges ( self )

Add halo exchanges before this loop as required by fields within
this loop. The PSyIR insertion logic is coded in the _add_halo_exchange
helper method.

Definition at line 576 of file gocean1p0.py.

     def create_halo_exchanges(self):
         '''Add halo exchanges before this loop as required by fields within
         this loop. The PSyIR insertion logic is coded in the _add_halo_exchange
         helper method. '''
  
         for halo_field in self.unique_fields_with_halo_reads():
             # for each unique field in this loop that has its halo
             # read, find the previous update of this field.
             prev_arg_list = halo_field.backward_write_dependencies()
             if not prev_arg_list:
                 # field has no previous dependence so create new halo
                 # exchange(s) as we don't know the state of the fields
                 # halo on entry to the invoke
                 # TODO 856: If dl_es_inf supported an is_dirty flag, we could
                 # be more selective on which HaloEx are needed. This
                 # function then will be the same as in LFRic and therefore
                 # the code can maybe be generalised.
                 self._add_halo_exchange(halo_field)
             else:
                 prev_node = prev_arg_list[0].call
                 if not isinstance(prev_node, HaloExchange):
                     # Previous dependence is not a halo exchange so one needs
                     # to be added to satisfy the dependency in distributed
                     # memory.
                     self._add_halo_exchange(halo_field)
  

References psyclone.domain.lfric.lfric_loop.LFRicLoop._add_halo_exchange(), psyclone.gocean1p0.GOLoop._add_halo_exchange(), psyclone.f2pygen.BaseGen.parent(), psyclone.psyir.nodes.node.Node.parent(), psyclone.f2pygen.Directive.position(), psyclone.psyir.nodes.node.Node.position, and psyclone.domain.common.psylayer.psyloop.PSyLoop.unique_fields_with_halo_reads().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ field_space() [1/2]

def psyclone.gocean1p0.GOLoop.field_space ( self )

:returns: the loop's field space (e.g. CU, CV...).
:rtype: str

Reimplemented from psyclone.domain.common.psylayer.psyloop.PSyLoop.

Definition at line 435 of file gocean1p0.py.

     def field_space(self):
         '''
         :returns: the loop's field space (e.g. CU, CV...).
         :rtype: str
         '''
         return self._field_space
  

References psyclone.domain.common.psylayer.psyloop.PSyLoop._field_space, psyclone.domain.lfric.lfric_loop.LFRicLoop._field_space, and psyclone.gocean1p0.GOLoop._field_space.

Here is the caller graph for this function:

◆ field_space() [2/2]

def psyclone.gocean1p0.GOLoop.field_space	(	self,
		my_field_space
	)

 Sets new value for the field_space and updates the Loop bounds,
if these exist, to match the given field_space.

:param str my_field_space: new field_space value.

:raises TypeError: if the provided field_space is not a string.
:raises ValueError: if the provided field_space is not a valid GOcean \
                    field_space.

Reimplemented from psyclone.domain.common.psylayer.psyloop.PSyLoop.

Definition at line 443 of file gocean1p0.py.

     def field_space(self, my_field_space):
         ''' Sets new value for the field_space and updates the Loop bounds,
         if these exist, to match the given field_space.
  
         :param str my_field_space: new field_space value.
  
         :raises TypeError: if the provided field_space is not a string.
         :raises ValueError: if the provided field_space is not a valid GOcean \
                             field_space.
  
         '''
         # TODO 1393: This could call the super setter if the validations are
         # generic
         if not isinstance(my_field_space, str):
             raise TypeError(
                 f"Field space must be a 'str' but found "
                 f"'{type(my_field_space).__name__}' instead.")
         valid_fs = GOceanConstants().VALID_FIELD_GRID_TYPES + ['']
         if my_field_space not in valid_fs:
             raise ValueError(
                 f"Invalid string '{my_field_space}' provided for a GOcean "
                 f"field_space. The valid values are {valid_fs}")
  
         self._field_space = my_field_space
         if len(self.children) > 1:
             self.start_expr.replace_with(self.lower_bound())
         if len(self.children) > 2:
             self.stop_expr.replace_with(self.upper_bound())
  

References psyclone.domain.common.psylayer.psyloop.PSyLoop._field_space, psyclone.domain.lfric.lfric_loop.LFRicLoop._field_space, psyclone.gocean1p0.GOLoop._field_space, psyclone.f2pygen.BaseGen.children(), psyclone.psyGen.InlinedKern.children, psyclone.psyir.nodes.node.Node.children(), psyclone.gocean1p0.GOLoop.lower_bound(), psyclone.psyir.backend.sympy_writer.SymPyWriter.lower_bound(), psyclone.domain.lfric.lfric_loop.LFRicLoop.start_expr(), psyclone.psyir.nodes.loop.Loop.start_expr(), psyclone.domain.lfric.lfric_loop.LFRicLoop.stop_expr(), psyclone.psyir.nodes.loop.Loop.stop_expr(), psyclone.gocean1p0.GOLoop.upper_bound(), and psyclone.psyir.backend.sympy_writer.SymPyWriter.upper_bound().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gen_code()

def psyclone.gocean1p0.GOLoop.gen_code	(	self,
		parent
	)

 Create the f2pygen AST for this loop (and update the PSyIR
representing the loop bounds if necessary).

:param parent: the node in the f2pygen AST to which to add content.
:type parent: :py:class:`psyclone.f2pygen.SubroutineGen`

Definition at line 992 of file gocean1p0.py.

     def gen_code(self, parent):
         ''' Create the f2pygen AST for this loop (and update the PSyIR
         representing the loop bounds if necessary).
  
         :param parent: the node in the f2pygen AST to which to add content.
         :type parent: :py:class:`psyclone.f2pygen.SubroutineGen`
  
         '''
         # Check that it is a properly formed GOLoop
         self._validate_loop()
  
         super().gen_code(parent)
  
  
 # pylint: disable=too-few-public-methods

References psyclone.gocean1p0.GOLoop._validate_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_custom_bound_string()

def psyclone.gocean1p0.GOLoop.get_custom_bound_string	(	self,
		side
	)

Get the string that represents a customized custom bound for this
GOLoop (provided by the add_bounds() method). It can provide the
'start' or 'stop' side of the bounds.

:param str side: 'start' or 'stop' side of the bound.

:returns: the string that represents the loop bound.
:rtype: str

:raises GenerationError: if this node can not find a field in \
    the Invoke to be the base of the infrastructure call.
:raises GenerationError: if no expression is known to obtain the \
    boundaries for a loop of this characteristics, because they \
    are not in the GOcean lookup table or the loop type is not \
    `inner` or `outer`.

Definition at line 795 of file gocean1p0.py.

     def get_custom_bound_string(self, side):
         '''
         Get the string that represents a customized custom bound for this
         GOLoop (provided by the add_bounds() method). It can provide the
         'start' or 'stop' side of the bounds.
  
         :param str side: 'start' or 'stop' side of the bound.
  
         :returns: the string that represents the loop bound.
         :rtype: str
  
         :raises GenerationError: if this node can not find a field in \
             the Invoke to be the base of the infrastructure call.
         :raises GenerationError: if no expression is known to obtain the \
             boundaries for a loop of this characteristics, because they \
             are not in the GOcean lookup table or the loop type is not \
             `inner` or `outer`.
         '''
         api_config = Config.get().api_conf("gocean1.0")
         # Get a field argument from the argument list
         field = None
         invoke = self.ancestor(InvokeSchedule)
         if invoke:
             for arg in invoke.symbol_table.argument_list:
                 if isinstance(arg.datatype, DataTypeSymbol):
                     if arg.datatype.name == "r2d_field":
                         field = arg
                         break
  
         if field is None:
             raise GenerationError(
                 f"Cannot generate custom loop bound for loop {self}. "
                 f"Couldn't find any suitable field.")
  
         if self.loop_type == "inner":
             prop_access = api_config.grid_properties["go_grid_xstop"]
         elif self.loop_type == "outer":
             prop_access = api_config.grid_properties["go_grid_ystop"]
         else:
             raise GenerationError(
                 f"Invalid loop type of '{self.loop_type}'. Expected one of "
                 f"{GOceanConstants().VALID_LOOP_TYPES}")
  
         stop_expr = prop_access.fortran.format(field.name)
         try:
             bound = self.bounds_lookup[self.index_offset][self.field_space][
                 self.iteration_space][self.loop_type][side].format(
                     start='2', stop=stop_expr)
         except KeyError as err:
             raise GenerationError(
                 f"Cannot generate custom loop bound for a loop with an index-"
                 f"offset of '{self.index_offset}', a field-space of "
                 f"'{self.field_space}', an iteration-space of "
                 f"'{self.iteration_space}' and a loop-type of "
                 f"'{self.loop_type}', for the side '{side}' because "
                 f"this keys combination does not exist in the "
                 f"GOLoop.bounds_lookup table.") from err
  
         return bound
  

Here is the call graph for this function:

Here is the caller graph for this function:

◆ independent_iterations()

def psyclone.gocean1p0.GOLoop.independent_iterations	(	self,
		test_all_variables = `False`,
		signatures_to_ignore = `None`,
		dep_tools = `None`
	)

This function is a GOcean-specific override of the default method
in the Loop class. It allows domain-specific rules to be applied when
determining whether or not loop iterations are independent.

:param bool test_all_variables: if True, it will test if all variable
    accesses are independent, otherwise it will stop after the first
    variable access is found that isn't.
:param signatures_to_ignore: list of signatures for which to skip
    the access checks.
:type signatures_to_ignore: Optional[
    List[:py:class:`psyclone.core.Signature`]]
:param dep_tools: an optional instance of DependencyTools so that the
    caller can access any diagnostic messages detailing why the loop
    iterations are not independent.
:type dep_tools: Optional[
    :py:class:`psyclone.psyir.tools.DependencyTools`]

:returns: True if the loop iterations are independent, False otherwise.
:rtype: bool

Definition at line 517 of file gocean1p0.py.

                                dep_tools=None):
         '''
         This function is a GOcean-specific override of the default method
         in the Loop class. It allows domain-specific rules to be applied when
         determining whether or not loop iterations are independent.
  
         :param bool test_all_variables: if True, it will test if all variable
             accesses are independent, otherwise it will stop after the first
             variable access is found that isn't.
         :param signatures_to_ignore: list of signatures for which to skip
             the access checks.
         :type signatures_to_ignore: Optional[
             List[:py:class:`psyclone.core.Signature`]]
         :param dep_tools: an optional instance of DependencyTools so that the
             caller can access any diagnostic messages detailing why the loop
             iterations are not independent.
         :type dep_tools: Optional[
             :py:class:`psyclone.psyir.tools.DependencyTools`]
  
         :returns: True if the loop iterations are independent, False otherwise.
         :rtype: bool
  
         '''
         if not dep_tools:
             dtools = DependencyTools()
         else:
             dtools = dep_tools
  
         try:
             stat = dtools.can_loop_be_parallelised(
                 self, test_all_variables=test_all_variables,
                 signatures_to_ignore=signatures_to_ignore)
             return stat
         except InternalError:
             # The dependence analysis in GOcean doesn't yet use PSyIR
             # consistently and that causes failures - TODO #845.
             return True
  

◆ iteration_space() [1/2]

def psyclone.gocean1p0.GOLoop.iteration_space ( self )

:returns: the loop's iteration space (e.g. 'go_internal_pts', \
          'go_all_pts', ...).
:rtype: str

Reimplemented from psyclone.domain.common.psylayer.psyloop.PSyLoop.

Definition at line 473 of file gocean1p0.py.

     def iteration_space(self):
         '''
         :returns: the loop's iteration space (e.g. 'go_internal_pts', \
                   'go_all_pts', ...).
         :rtype: str
         '''
         return self._iteration_space
  

References psyclone.domain.common.psylayer.psyloop.PSyLoop._iteration_space, psyclone.domain.lfric.lfric_loop.LFRicLoop._iteration_space, and psyclone.gocean1p0.GOLoop._iteration_space.

Here is the caller graph for this function:

◆ iteration_space() [2/2]

def psyclone.gocean1p0.GOLoop.iteration_space	(	self,
		it_space
	)

 Sets new value for the iteration_space and updates the Loop bounds,
if these exist, to match the given iteration_space.

:param str it_space: new iteration_space value.

:raises TypeError: if the provided it_space is not a string.

Reimplemented from psyclone.domain.common.psylayer.psyloop.PSyLoop.

Definition at line 482 of file gocean1p0.py.

     def iteration_space(self, it_space):
         ''' Sets new value for the iteration_space and updates the Loop bounds,
         if these exist, to match the given iteration_space.
  
         :param str it_space: new iteration_space value.
  
         :raises TypeError: if the provided it_space is not a string.
  
         '''
         if not isinstance(it_space, str):
             raise TypeError(
                 f"Iteration space must be a 'str' but found "
                 f"'{type(it_space).__name__}' instead.")
  
         # TODO 1393: We could validate also the value, but at the moment there
         # are some ambiguities to resolve.
  
         self._iteration_space = it_space
         if len(self.children) > 1:
             self.start_expr.replace_with(self.lower_bound())
         if len(self.children) > 2:
             self.stop_expr.replace_with(self.upper_bound())
  

References psyclone.domain.common.psylayer.psyloop.PSyLoop._iteration_space, psyclone.domain.lfric.lfric_loop.LFRicLoop._iteration_space, psyclone.gocean1p0.GOLoop._iteration_space, psyclone.f2pygen.BaseGen.children(), psyclone.psyGen.InlinedKern.children, psyclone.psyir.nodes.node.Node.children(), psyclone.gocean1p0.GOLoop.lower_bound(), psyclone.psyir.backend.sympy_writer.SymPyWriter.lower_bound(), psyclone.domain.lfric.lfric_loop.LFRicLoop.start_expr(), psyclone.psyir.nodes.loop.Loop.start_expr(), psyclone.domain.lfric.lfric_loop.LFRicLoop.stop_expr(), psyclone.psyir.nodes.loop.Loop.stop_expr(), psyclone.gocean1p0.GOLoop.upper_bound(), and psyclone.psyir.backend.sympy_writer.SymPyWriter.upper_bound().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lower_bound()

def psyclone.gocean1p0.GOLoop.lower_bound ( self )

 Returns the lower bound of this loop as a string.

:returns: root of PSyIR sub-tree describing this lower bound.
:rtype: :py:class:`psyclone.psyir.nodes.Node`

Definition at line 928 of file gocean1p0.py.

     def lower_bound(self):
         ''' Returns the lower bound of this loop as a string.
  
         :returns: root of PSyIR sub-tree describing this lower bound.
         :rtype: :py:class:`psyclone.psyir.nodes.Node`
  
         '''
         if self.field_space == "go_every":
             # Bounds are independent of the grid-offset convention in use
             return Literal("1", INTEGER_TYPE)
  
         # Loop bounds are pulled from a infrastructure call from a field
         # object. For 'go_internal_pts' and 'go_all_points' we use the
         # 'internal' and 'whole' structures respectively. For other
         # iteration_spaces we look if a custom expression is defined in the
         # lookup table.
         props = Config.get().api_conf("gocean1.0").grid_properties
         if self.iteration_space.lower() == "go_internal_pts":
             return self._grid_property_psyir_expression(
                 props[f"go_grid_internal_{self._loop_type}_start"].fortran)
         if self.iteration_space.lower() == "go_all_pts":
             return self._grid_property_psyir_expression(
                 props[f"go_grid_whole_{self._loop_type}_start"].fortran)
         bound_str = self.get_custom_bound_string("start")
         return FortranReader().psyir_from_expression(
                     bound_str, self.ancestor(GOInvokeSchedule).symbol_table)
  

References psyclone.gocean1p0.GOLoop._grid_property_psyir_expression(), psyclone.psyir.nodes.node.Node.ancestor(), psyclone.domain.common.psylayer.psyloop.PSyLoop.field_space, psyclone.gocean1p0.GOLoop.field_space, psyclone.gocean1p0.GOLoop.get_custom_bound_string(), psyclone.domain.common.psylayer.psyloop.PSyLoop.iteration_space, psyclone.gocean1p0.GOLoop.iteration_space, and psyclone.psyir.nodes.node.Node.walk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setup_bounds()

def psyclone.gocean1p0.GOLoop.setup_bounds ( )

static

Populates the GOLoop._bounds_lookup dictionary. This is
used by PSyclone to look up the loop boundaries for each loop
it creates.

Definition at line 616 of file gocean1p0.py.

     def setup_bounds():
         '''Populates the GOLoop._bounds_lookup dictionary. This is
         used by PSyclone to look up the loop boundaries for each loop
         it creates.
  
         '''
         const = GOceanConstants()
         for grid_offset in const.SUPPORTED_OFFSETS:
             GOLoop._bounds_lookup[grid_offset] = {}
             for gridpt_type in const.VALID_FIELD_GRID_TYPES:
                 GOLoop._bounds_lookup[grid_offset][gridpt_type] = {}
                 for itspace in const.VALID_ITERATES_OVER:
                     GOLoop._bounds_lookup[grid_offset][gridpt_type][
                         itspace] = {}
  
         # Loop bounds for a mesh with NE offset
         GOLoop._bounds_lookup['go_offset_ne']['go_ct']['go_all_pts'] = \
             {'inner': {'start': "{start}-1", 'stop': "{stop}+1"},
              'outer': {'start': "{start}-1", 'stop': "{stop}+1"}}
         GOLoop._bounds_lookup['go_offset_ne']['go_ct']['go_internal_pts'] = \
             {'inner': {'start': "{start}", 'stop': "{stop}"},
              'outer': {'start': "{start}", 'stop': "{stop}"}}
         GOLoop._bounds_lookup['go_offset_ne']['go_cu']['go_all_pts'] = \
             {'inner': {'start': "{start}-1", 'stop': "{stop}"},
              'outer': {'start': "{start}-1", 'stop': "{stop}+1"}}
         GOLoop._bounds_lookup['go_offset_ne']['go_cu']['go_internal_pts'] = \
             {'inner': {'start': "{start}", 'stop': "{stop}-1"},
              'outer': {'start': "{start}", 'stop': "{stop}"}}
         GOLoop._bounds_lookup['go_offset_ne']['go_cv']['go_all_pts'] = \
             {'inner': {'start': "{start}-1", 'stop': "{stop}+1"},
              'outer': {'start': "{start}-1", 'stop': "{stop}"}}
         GOLoop._bounds_lookup['go_offset_ne']['go_cv']['go_internal_pts'] = \
             {'inner': {'start': "{start}", 'stop': "{stop}"},
              'outer': {'start': "{start}", 'stop': "{stop}-1"}}
         GOLoop._bounds_lookup['go_offset_ne']['go_cf']['go_all_pts'] = \
             {'inner': {'start': "{start}-1", 'stop': "{stop}"},
              'outer': {'start': "{start}-1", 'stop': "{stop}"}}
         GOLoop._bounds_lookup['go_offset_ne']['go_cf']['go_internal_pts'] = \
             {'inner': {'start': "{start}-1", 'stop': "{stop}-1"},
              'outer': {'start': "{start}-1", 'stop': "{stop}-1"}}
         # Loop bounds for a mesh with SE offset
         GOLoop._bounds_lookup['go_offset_sw']['go_ct']['go_all_pts'] = \
             {'inner': {'start': "{start}-1", 'stop': "{stop}+1"},
              'outer': {'start': "{start}-1", 'stop': "{stop}+1"}}
         GOLoop._bounds_lookup['go_offset_sw']['go_ct']['go_internal_pts'] = \
             {'inner': {'start': "{start}", 'stop': "{stop}"},
              'outer': {'start': "{start}", 'stop': "{stop}"}}
         GOLoop._bounds_lookup['go_offset_sw']['go_cu']['go_all_pts'] = \
             {'inner': {'start': "{start}-1", 'stop': "{stop}+1"},
              'outer': {'start': "{start}-1", 'stop': "{stop}+1"}}
         GOLoop._bounds_lookup['go_offset_sw']['go_cu']['go_internal_pts'] = \
             {'inner': {'start': "{start}", 'stop': "{stop}+1"},
              'outer': {'start': "{start}", 'stop': "{stop}"}}
         GOLoop._bounds_lookup['go_offset_sw']['go_cv']['go_all_pts'] = \
             {'inner': {'start': "{start}-1", 'stop': "{stop}+1"},
              'outer': {'start': "{start}-1", 'stop': "{stop}+1"}}
         GOLoop._bounds_lookup['go_offset_sw']['go_cv']['go_internal_pts'] = \
             {'inner': {'start': "{start}", 'stop': "{stop}"},
              'outer': {'start': "{start}", 'stop': "{stop}+1"}}
         GOLoop._bounds_lookup['go_offset_sw']['go_cf']['go_all_pts'] = \
             {'inner': {'start': "{start}-1", 'stop': "{stop}+1"},
              'outer': {'start': "{start}-1", 'stop': "{stop}+1"}}
         GOLoop._bounds_lookup['go_offset_sw']['go_cf']['go_internal_pts'] = \
             {'inner': {'start': "{start}", 'stop': "{stop}+1"},
              'outer': {'start': "{start}", 'stop': "{stop}+1"}}
         # For offset 'any'
         for gridpt_type in const.VALID_FIELD_GRID_TYPES:
             for itspace in const.VALID_ITERATES_OVER:
                 GOLoop._bounds_lookup['go_offset_any'][gridpt_type][itspace] =\
                     {'inner': {'start': "{start}-1", 'stop': "{stop}"},
                      'outer': {'start': "{start}-1", 'stop': "{stop}"}}
         # For 'every' grid-point type
         for offset in const.SUPPORTED_OFFSETS:
             for itspace in const.VALID_ITERATES_OVER:
                 GOLoop._bounds_lookup[offset]['go_every'][itspace] = \
                     {'inner': {'start': "{start}-1", 'stop': "{stop}+1"},
                      'outer': {'start': "{start}-1", 'stop': "{stop}+1"}}
  

◆ upper_bound()

def psyclone.gocean1p0.GOLoop.upper_bound ( self )

 Creates the PSyIR of the upper bound of this loop.

:returns: the PSyIR for the upper bound of this loop.
:rtype: :py:class:`psyclone.psyir.nodes.Node`

Definition at line 888 of file gocean1p0.py.

     def upper_bound(self):
         ''' Creates the PSyIR of the upper bound of this loop.
  
         :returns: the PSyIR for the upper bound of this loop.
         :rtype: :py:class:`psyclone.psyir.nodes.Node`
  
         '''
         if self.field_space == "go_every":
             # Bounds are independent of the grid-offset convention in use
             # We look-up the upper bounds by enquiring about the SIZE of
             # the array itself
             stop = IntrinsicCall(IntrinsicCall.Intrinsic.SIZE)
             # Use the data property to access the member of the field that
             # contains the actual grid points.
             api_config = Config.get().api_conf("gocean1.0")
             sref = self._grid_property_psyir_expression(
                 api_config.grid_properties["go_grid_data"].fortran)
             stop.addchild(sref)
             if self._loop_type == "inner":
                 stop.addchild(Literal("1", INTEGER_TYPE, parent=stop))
             elif self._loop_type == "outer":
                 stop.addchild(Literal("2", INTEGER_TYPE, parent=stop))
             return stop
  
         # Loop bounds are pulled from a infrastructure call from a field
         # object. For 'go_internal_pts' and 'go_all_points' we use the
         # 'internal' and 'whole' structures respectively. For other
         # iteration_spaces we look if a custom expression is defined in the
         # lookup table.
         props = Config.get().api_conf("gocean1.0").grid_properties
         if self.iteration_space.lower() == "go_internal_pts":
             return self._grid_property_psyir_expression(
                 props[f"go_grid_internal_{self._loop_type}_stop"].fortran)
         if self.iteration_space.lower() == "go_all_pts":
             return self._grid_property_psyir_expression(
                 props[f"go_grid_whole_{self._loop_type}_stop"].fortran)
         bound_str = self.get_custom_bound_string("stop")
         return FortranReader().psyir_from_expression(
                     bound_str, self.ancestor(GOInvokeSchedule).symbol_table)
  

References psyclone.gocean1p0.GOLoop._grid_property_psyir_expression(), psyclone.domain.common.psylayer.psyloop.PSyLoop._loop_type, psyclone.domain.lfric.lfric_loop.LFRicLoop._loop_type, psyclone.gocean1p0.GOLoop._loop_type, psyclone.psyir.nodes.node.Node.ancestor(), psyclone.domain.common.psylayer.psyloop.PSyLoop.field_space, psyclone.gocean1p0.GOLoop.field_space, psyclone.gocean1p0.GOLoop.get_custom_bound_string(), psyclone.domain.common.psylayer.psyloop.PSyLoop.iteration_space, and psyclone.gocean1p0.GOLoop.iteration_space.

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

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

◆ add_bounds()

◆ bounds_lookup()

◆ create()

◆ create_halo_exchanges()

◆ field_space() [1/2]

◆ field_space() [2/2]

◆ gen_code()

◆ get_custom_bound_string()

◆ independent_iterations()

◆ iteration_space() [1/2]

◆ iteration_space() [2/2]

◆ lower_bound()

◆ setup_bounds()

◆ upper_bound()