Inheritance diagram for psyclone.domain.gocean.transformations.gocean_move_iteration_boundaries_inside_kernel_trans.GOMoveIterationBoundariesInsideKernelTrans:

[legend]

Collaboration diagram for psyclone.domain.gocean.transformations.gocean_move_iteration_boundaries_inside_kernel_trans.GOMoveIterationBoundariesInsideKernelTrans:

[legend]

Public Member Functions
def	__str__ (self)

def	name (self)

def	validate (self, node, options=None)

def	apply (self, node, options=None)

Detailed Description

 Provides a transformation that moves iteration boundaries that are
encoded in the Loops lower_bound() and upper_bound() methods to a mask
inside the kernel with the boundaries passed as kernel arguments.

For example the following kernel call:

.. code-block:: fortran

    do i = 2, N - 1
        do j = 2, N - 1
            kernel(i, j, field)
        end do
    end do

will be transformed to:

.. code-block:: fortran

    startx = 2
    stopx = N - 1
    starty = 2
    stopy = N - 1
    do i = 1, size(field, 1)
        do j = 1, size(field, 2)
            kernel(i, j, field, startx, stopx, starty, stopy)
        end do
    end do

additionally a mask like the following one will be introduced in the
kernel code:

.. code-block:: fortran

    if (i < startx .or. i > stopx .or. j < starty .or. j > stopy) then
        return
    end if

Definition at line 47 of file gocean_move_iteration_boundaries_inside_kernel_trans.py.

Member Function Documentation

◆ apply()

def psyclone.domain.gocean.transformations.gocean_move_iteration_boundaries_inside_kernel_trans.GOMoveIterationBoundariesInsideKernelTrans.apply	(	self,
		node,
		options = `None`
	)

Apply this transformation to the supplied node.

:param node: the node to transform.
:type node: :py:class:`psyclone.gocean1p0.GOKern`
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 112 of file gocean_move_iteration_boundaries_inside_kernel_trans.py.

     def apply(self, node, options=None):
         '''Apply this transformation to the supplied node.
  
         :param node: the node to transform.
         :type node: :py:class:`psyclone.gocean1p0.GOKern`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
  
         '''
         self.validate(node, options)
  
         # Get useful references
         invoke_st = node.ancestor(InvokeSchedule).symbol_table
         inner_loop = node.ancestor(Loop)
         outer_loop = inner_loop.ancestor(Loop)
         cursor = outer_loop.position
  
         # Make sure the boundary symbols in the PSylayer exist
         inv_xstart = invoke_st.find_or_create_tag(
             "xstart_" + node.name, root_name="xstart", symbol_type=DataSymbol,
             datatype=INTEGER_TYPE)
         inv_xstop = invoke_st.find_or_create_tag(
             "xstop_" + node.name, root_name="xstop", symbol_type=DataSymbol,
             datatype=INTEGER_TYPE)
         inv_ystart = invoke_st.find_or_create_tag(
             "ystart_" + node.name, root_name="ystart", symbol_type=DataSymbol,
             datatype=INTEGER_TYPE)
         inv_ystop = invoke_st.find_or_create_tag(
             "ystop_" + node.name, root_name="ystop", symbol_type=DataSymbol,
             datatype=INTEGER_TYPE)
  
         # If the kernel acts on the whole iteration space, the boundary values
         # are not needed. This also avoids adding duplicated arguments if this
         # transformation is applied more than once to the same kernel. But the
         # declaration and initialisation above still needs to exist because the
         # boundary variables are expected to exist by the generation code.
         if (inner_loop.field_space == "go_every" and
                 outer_loop.field_space == "go_every" and
                 inner_loop.iteration_space == "go_all_pts" and
                 outer_loop.iteration_space == "go_all_pts"):
             return node.root, None
  
         # Initialise the boundary values provided by the Loop construct
         assign1 = Assignment.create(Reference(inv_xstart),
                                     inner_loop.start_expr.copy())
         outer_loop.parent.children.insert(cursor, assign1)
         cursor = cursor + 1
         assign2 = Assignment.create(Reference(inv_xstop),
                                     inner_loop.stop_expr.copy())
         outer_loop.parent.children.insert(cursor, assign2)
         cursor = cursor + 1
         assign3 = Assignment.create(Reference(inv_ystart),
                                     outer_loop.start_expr.copy())
         outer_loop.parent.children.insert(cursor, assign3)
         cursor = cursor + 1
         assign4 = Assignment.create(Reference(inv_ystop),
                                     outer_loop.stop_expr.copy())
         outer_loop.parent.children.insert(cursor, assign4)
  
         # Update Kernel Call argument list
         for symbol in [inv_xstart, inv_xstop, inv_ystart, inv_ystop]:
             node.arguments.append(symbol.name, "go_i_scalar")
  
         # Now that the boundaries are inside the kernel, the looping should go
         # through all the field points
         inner_loop.field_space = "go_every"
         outer_loop.field_space = "go_every"
         inner_loop.iteration_space = "go_all_pts"
         outer_loop.iteration_space = "go_all_pts"
  
         # Update Kernel
         kschedule = node.get_kernel_schedule()
         kernel_st = kschedule.symbol_table
         iteration_indices = kernel_st.iteration_indices
         data_arguments = kernel_st.data_arguments
  
         # Create new symbols and insert them as kernel arguments at the end of
         # the kernel argument list
         xstart_symbol = kernel_st.new_symbol(
             "xstart", symbol_type=DataSymbol, datatype=INTEGER_TYPE,
             interface=ArgumentInterface(ArgumentInterface.Access.READ))
         xstop_symbol = kernel_st.new_symbol(
             "xstop", symbol_type=DataSymbol, datatype=INTEGER_TYPE,
             interface=ArgumentInterface(ArgumentInterface.Access.READ))
         ystart_symbol = kernel_st.new_symbol(
             "ystart", symbol_type=DataSymbol, datatype=INTEGER_TYPE,
             interface=ArgumentInterface(ArgumentInterface.Access.READ))
         ystop_symbol = kernel_st.new_symbol(
             "ystop", symbol_type=DataSymbol, datatype=INTEGER_TYPE,
             interface=ArgumentInterface(ArgumentInterface.Access.READ))
         kernel_st.specify_argument_list(
             iteration_indices + data_arguments +
             [xstart_symbol, xstop_symbol, ystart_symbol, ystop_symbol])
  
         # Create boundary masking conditions
         condition1 = BinaryOperation.create(
             BinaryOperation.Operator.LT,
             Reference(iteration_indices[0]),
             Reference(xstart_symbol))
         condition2 = BinaryOperation.create(
             BinaryOperation.Operator.GT,
             Reference(iteration_indices[0]),
             Reference(xstop_symbol))
         condition3 = BinaryOperation.create(
             BinaryOperation.Operator.LT,
             Reference(iteration_indices[1]),
             Reference(ystart_symbol))
         condition4 = BinaryOperation.create(
             BinaryOperation.Operator.GT,
             Reference(iteration_indices[1]),
             Reference(ystop_symbol))
  
         condition = BinaryOperation.create(
             BinaryOperation.Operator.OR,
             BinaryOperation.create(
                 BinaryOperation.Operator.OR,
                 condition1,
                 condition2),
             BinaryOperation.create(
                 BinaryOperation.Operator.OR,
                 condition3,
                 condition4)
             )
  
         # Insert the conditional mask as the first statement of the kernel
         if_statement = IfBlock.create(condition, [Return()])
         kschedule.children.insert(0, if_statement)
  
  
 # For Sphinx AutoAPI documentation generation

Here is the call graph for this function:

◆ name()

def psyclone.domain.gocean.transformations.gocean_move_iteration_boundaries_inside_kernel_trans.GOMoveIterationBoundariesInsideKernelTrans.name ( self )

Returns the name of this transformation as a string.

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 90 of file gocean_move_iteration_boundaries_inside_kernel_trans.py.

     def name(self):
         '''Returns the name of this transformation as a string.'''
         return "GOMoveIterationBoundariesInsideKernelTrans"
  

Here is the caller graph for this function:

◆ validate()

def psyclone.domain.gocean.transformations.gocean_move_iteration_boundaries_inside_kernel_trans.GOMoveIterationBoundariesInsideKernelTrans.validate	(	self,
		node,
		options = `None`
	)

Ensure that it is valid to apply this transformation to the
supplied node.

:param node: the node to validate.
:type node: :py:class:`psyclone.gocean1p0.GOKern`
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]

:raises TransformationError: if the node is not a GOKern.

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 94 of file gocean_move_iteration_boundaries_inside_kernel_trans.py.

     def validate(self, node, options=None):
         '''Ensure that it is valid to apply this transformation to the
         supplied node.
  
         :param node: the node to validate.
         :type node: :py:class:`psyclone.gocean1p0.GOKern`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
  
         :raises TransformationError: if the node is not a GOKern.
  
         '''
         if not isinstance(node, GOKern):
             raise TransformationError(
                 f"Error in {self.name} transformation. This transformation "
                 f"can only be applied to 'GOKern' nodes, but found "
                 f"'{type(node).__name__}'.")
  

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/domain/gocean/transformations/gocean_move_iteration_boundaries_inside_kernel_trans.py

Public Member Functions

Detailed Description

Member Function Documentation

◆ apply()

◆ name()

◆ validate()