Inheritance diagram for psyclone.domain.nemo.transformations.create_nemo_invoke_schedule_trans.CreateNemoInvokeScheduleTrans:

[legend]

Collaboration diagram for psyclone.domain.nemo.transformations.create_nemo_invoke_schedule_trans.CreateNemoInvokeScheduleTrans:

[legend]

Public Member Functions
def	name (self)

def	validate (self, node, options=None)

def	apply (self, node, options=None)

Detailed Description

Transform a generic PSyIR Routine into a NEMO InvokeSchedule.
For example:

>>> from psyclone.psyir.frontend.fortran import FortranReader
>>> from psyclone.psyir.nodes import Loop
>>> from psyclone.domain.nemo.transformations import \
CreateNemoInvokeScheduleTrans
>>> code = '''
... subroutine sub()
...   integer :: ji
...   real :: tmp(10)
...   do ji=1, 10
...     tmp(ji) = 2.0*ji
...   end do
... end subroutine sub'''
>>> psyir = FortranReader().psyir_from_source(code)
>>> loop = psyir.walk(Loop)[0]
>>> trans = CreateNemoInvokeScheduleTrans()
>>> trans.apply(psyir.children[0])
>>> print(psyir.view(colour=False))
FileContainer[]
    NemoInvokeSchedule[invoke='sub']
        0: Loop[variable='ji']
            Literal[value:'1', Scalar<INTEGER, UNDEFINED>]
            Literal[value:'10', Scalar<INTEGER, UNDEFINED>]
            Literal[value:'1', Scalar<INTEGER, UNDEFINED>]
            Schedule[]
                0: Assignment[]
                    ArrayReference[name:'tmp']
                        Reference[name:'ji']
                    BinaryOperation[operator:'MUL']
                        Literal[value:'2.0', Scalar<REAL, UNDEFINED>]
                        Reference[name:'ji']
<BLANKLINE>

The root node of this example has been transformed from a Routine into a
NemoInvokeSchedule.

Definition at line 47 of file create_nemo_invoke_schedule_trans.py.

Member Function Documentation

◆ apply()

def psyclone.domain.nemo.transformations.create_nemo_invoke_schedule_trans.CreateNemoInvokeScheduleTrans.apply	(	self,
		node,
		options = `None`
	)

Takes a generic PSyIR Routine and replaces it with a
NemoInvokeSchedule (in-place). Note that this may mean replacing
the top-level node itself and therefore this routine returns the
root of the modified tree.

:param node: the routine node to be transformed.
:type node: :py:class:`psyclone.psyir.nodes.Routine`
:param options: a dictionary with options for \
    transformations. No options are used in this \
    transformation. This is an optional argument that defaults \
    to None.
:type options: Optional[Dict[str, Any]]

Definition at line 122 of file create_nemo_invoke_schedule_trans.py.

     def apply(self, node, options=None):
         '''
         Takes a generic PSyIR Routine and replaces it with a
         NemoInvokeSchedule (in-place). Note that this may mean replacing
         the top-level node itself and therefore this routine returns the
         root of the modified tree.
  
         :param node: the routine node to be transformed.
         :type node: :py:class:`psyclone.psyir.nodes.Routine`
         :param options: a dictionary with options for \
             transformations. No options are used in this \
             transformation. This is an optional argument that defaults \
             to None.
         :type options: Optional[Dict[str, Any]]
  
         '''
         self.validate(node, options=options)
  
         # If it's a function we need to provide the return_symbol_name to the
         # create method
         return_symbol_name = None
         if node.return_symbol:
             return_symbol_name = node.return_symbol.name
  
         new_node = NemoInvokeSchedule.create(
             node.name, node.symbol_table.detach(), node.pop_all_children(),
             is_program=node.is_program,
             return_symbol_name=return_symbol_name)
  
         # We need to replace the top node in the (possibly sub-) PSyIR
         # tree that we've been passed.
         if node.parent:
             node.replace_with(new_node)
  
  
 # For AutoAPI documentation generation

Here is the call graph for this function:

◆ name()

def psyclone.domain.nemo.transformations.create_nemo_invoke_schedule_trans.CreateNemoInvokeScheduleTrans.name ( self )

:returns: the name of the transformation.
:rtype: str

TODO #1214 remove this method.

Definition at line 89 of file create_nemo_invoke_schedule_trans.py.

     def name(self):
         '''
         :returns: the name of the transformation.
         :rtype: str
  
         TODO #1214 remove this method.
  
         '''
         return type(self).__name__
  

Here is the caller graph for this function:

◆ validate()

def psyclone.domain.nemo.transformations.create_nemo_invoke_schedule_trans.CreateNemoInvokeScheduleTrans.validate	(	self,
		node,
		options = `None`
	)

Check that the supplied node is a valid target for this transformation.

:param node: the target of the transformation.
:type node: :py:class:`psyclone.psyir.nodes.Node`
:param options: a dictionary with options for \
    transformations. No options are used in this \
    transformation. This is an optional argument that defaults \
    to None.
:type options: Optional[Dict[str, Any]]

:raises TransformationError: if the supplied node is not a Routine.

Definition at line 99 of file create_nemo_invoke_schedule_trans.py.

     def validate(self, node, options=None):
         '''
         Check that the supplied node is a valid target for this transformation.
  
         :param node: the target of the transformation.
         :type node: :py:class:`psyclone.psyir.nodes.Node`
         :param options: a dictionary with options for \
             transformations. No options are used in this \
             transformation. This is an optional argument that defaults \
             to None.
         :type options: Optional[Dict[str, Any]]
  
         :raises TransformationError: if the supplied node is not a Routine.
  
         '''
         super(CreateNemoInvokeScheduleTrans, self).validate(node,
                                                             options=options)
  
         if not isinstance(node, Routine):
             raise TransformationError(
                 f"Error in NemoInvokeTrans transformation. The supplied node "
                 f"should be a PSyIR Routine but found '{type(node).__name__}'")
  