Inheritance diagram for psyclone.psyir.nodes.routine.Routine:

[legend]

Collaboration diagram for psyclone.psyir.nodes.routine.Routine:

[legend]

Public Member Functions
def	__init__ (self, name, is_program=False, **kwargs)

def	__eq__ (self, other)

def	create (cls, name, symbol_table, children, is_program=False, return_symbol_name=None)

def	node_str (self, colour=True)

def	dag_name (self)

def	name (self)

def	name (self, new_name)

def	__str__ (self)

def	is_program (self)

def	return_symbol (self)

def	return_symbol (self, value)

Public Member Functions inherited from psyclone.psyir.nodes.schedule.Schedule
def	__getitem__ (self, index)

def	gen_code (self, parent)

Public Member Functions inherited from psyclone.psyir.nodes.scoping_node.ScopingNode
def	__init__ (self, children=None, parent=None, symbol_table=None)

def	symbol_table (self)

Public Member Functions inherited from psyclone.psyir.nodes.node.Node
def	__init__ (self, ast=None, children=None, parent=None, annotations=None)

def	coloured_name (self, colour=True)

def	ast (self)

def	ast_end (self)

def	ast (self, ast)

def	ast_end (self, ast_end)

def	annotations (self)

def	dag (self, file_name='dag', file_format='svg')

def	dag_gen (self, graph)

def	args (self)

def	backward_dependence (self)

def	forward_dependence (self)

def	is_valid_location (self, new_node, position="before")

def	depth (self)

def	view (self, depth=0, colour=True, indent=" ", _index=None)

def	addchild (self, child, index=None)

def	children (self)

def	children (self, my_children)

def	parent (self)

def	siblings (self)

def	has_constructor_parent (self)

def	position (self)

def	abs_position (self)

def	root (self)

def	sameParent (self, node_2)

def	walk (self, my_type, stop_type=None, depth=None)

def	get_sibling_lists (self, my_type, stop_type=None)

def	ancestor (self, my_type, excluding=None, include_self=False, limit=None, shared_with=None)

def	kernels (self)

def	following (self, routine=True)

def	preceding (self, reverse=False, routine=True)

def	immediately_precedes (self, node_2)

def	immediately_follows (self, node_1)

def	coded_kernels (self)

def	loops (self)

def	reductions (self, reprod=None)

def	is_openmp_parallel (self)

def	lower_to_language_level (self)

def	reference_accesses (self, var_accesses)

def	scope (self)

def	replace_with (self, node, keep_name_in_context=True)

def	pop_all_children (self)

def	detach (self)

def	copy (self)

def	validate_global_constraints (self)

def	debug_string (self)

def	origin_string (self)

def	update_signal (self)

def	path_from (self, ancestor)

Public Member Functions inherited from psyclone.psyir.nodes.commentable_mixin.CommentableMixin
def	preceding_comment (self)

def	preceding_comment (self, comment)

def	inline_comment (self)

def	inline_comment (self, comment)

Public Attributes
	name

	is_program

	return_symbol

Public Attributes inherited from psyclone.psyir.nodes.scoping_node.ScopingNode
	symbol_table

Public Attributes inherited from psyclone.psyir.nodes.node.Node
	position

Additional Inherited Members
Static Public Attributes inherited from psyclone.psyir.nodes.node.Node
int	START_DEPTH = 0

int	START_POSITION = 0

	valid_annotations = tuple()

Detailed Description

A sub-class of a Schedule that represents a subroutine, function or
program unit.

:param str name: the name of this routine.
:param bool is_program: whether this Routine represents the entry point \
                        into a program (e.g. Fortran Program or C main()).
:param kwargs: additional keyword arguments provided to the super class.
:type kwargs: unwrapped dict.

:raises TypeError: if any of the supplied arguments are of the wrong type.

Definition at line 49 of file routine.py.

Member Function Documentation

◆ eq()

def psyclone.psyir.nodes.routine.Routine.__eq__	(	self,
		other
	)

Checks whether two nodes are equal. Two Routine nodes are equal
if they have the same name, same return symbol, same properties and
the inherited __eq__ is True.

:param object other: the object to check equality to.

:returns: whether other is equal to self.
:rtype: bool

Reimplemented from psyclone.psyir.nodes.scoping_node.ScopingNode.

Definition at line 80 of file routine.py.

     def __eq__(self, other):
         '''
         Checks whether two nodes are equal. Two Routine nodes are equal
         if they have the same name, same return symbol, same properties and
         the inherited __eq__ is True.
  
         :param object other: the object to check equality to.
  
         :returns: whether other is equal to self.
         :rtype: bool
         '''
         is_eq = super().__eq__(other)
         is_eq = is_eq and self.name == other.name
         is_eq = is_eq and self.is_program == other.is_program
         is_eq = is_eq and self.return_symbol == other.return_symbol
  
         return is_eq
  

Here is the call graph for this function:

◆ create()

def psyclone.psyir.nodes.routine.Routine.create	(	cls,
		name,
		symbol_table,
		children,
		is_program = `False`,
		return_symbol_name = `None`
	)

Create an instance of the supplied class given a name, a symbol
table and a list of child nodes. This is implemented as a classmethod
so that it is able to act as a Factory for subclasses - e.g. it
will create a KernelSchedule if called from KernelSchedule.create().

:param str name: the name of the Routine (or subclass).
:param symbol_table: the symbol table associated with this Routine.
:type symbol_table: :py:class:`psyclone.psyGen.SymbolTable`
:param children: a list of PSyIR nodes contained in the Routine.
:type children: list of :py:class:`psyclone.psyir.nodes.Node`
:param bool is_program: whether this Routine represents the entry \
    point into a program (i.e. Fortran Program or C main()).
:param str return_symbol_name: name of the symbol that holds the \
    return value of this routine (if any). Must be present in the \
    supplied symbol table.

:returns: an instance of `cls`.
:rtype: :py:class:`psyclone.psyGen.Routine` or subclass

:raises TypeError: if the arguments to the create method \
    are not of the expected type.

Definition at line 99 of file routine.py.

                return_symbol_name=None):
         # pylint: disable=too-many-arguments
         '''Create an instance of the supplied class given a name, a symbol
         table and a list of child nodes. This is implemented as a classmethod
         so that it is able to act as a Factory for subclasses - e.g. it
         will create a KernelSchedule if called from KernelSchedule.create().
  
         :param str name: the name of the Routine (or subclass).
         :param symbol_table: the symbol table associated with this Routine.
         :type symbol_table: :py:class:`psyclone.psyGen.SymbolTable`
         :param children: a list of PSyIR nodes contained in the Routine.
         :type children: list of :py:class:`psyclone.psyir.nodes.Node`
         :param bool is_program: whether this Routine represents the entry \
             point into a program (i.e. Fortran Program or C main()).
         :param str return_symbol_name: name of the symbol that holds the \
             return value of this routine (if any). Must be present in the \
             supplied symbol table.
  
         :returns: an instance of `cls`.
         :rtype: :py:class:`psyclone.psyGen.Routine` or subclass
  
         :raises TypeError: if the arguments to the create method \
             are not of the expected type.
  
         '''
         if not isinstance(name, str):
             raise TypeError(
                 f"name argument in create method of Routine class "
                 f"should be a string but found '{type(name).__name__}'.")
         if not isinstance(symbol_table, SymbolTable):
             raise TypeError(
                 f"symbol_table argument in create method of Routine class "
                 f"should be a SymbolTable but found "
                 f"'{type(symbol_table).__name__}'.")
         if not isinstance(children, list):
             raise TypeError(
                 f"children argument in create method of Routine class "
                 f"should be a list but found '{type(children).__name__}'.")
         for child in children:
             if not isinstance(child, Node):
                 raise TypeError(
                     f"child of children argument in create method of "
                     f"Routine class should be a PSyIR Node but "
                     f"found '{type(child).__name__}'.")
  
         routine = cls(name, is_program=is_program, symbol_table=symbol_table)
         routine.children = children
         if return_symbol_name:
             routine.return_symbol = routine.symbol_table.lookup(
                                        return_symbol_name, scope_limit=routine)
         return routine
  

Here is the caller graph for this function:

◆ dag_name()

def psyclone.psyir.nodes.routine.Routine.dag_name ( self )

:returns: the name of this node in the dag.
:rtype: str

Reimplemented from psyclone.psyir.nodes.node.Node.

Definition at line 164 of file routine.py.

     def dag_name(self):
         '''
         :returns: the name of this node in the dag.
         :rtype: str
         '''
         return "_".join(["routine", self.name, str(self.START_POSITION)])
  

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_program()

def psyclone.psyir.nodes.routine.Routine.is_program ( self )

:returns: whether this Routine represents the entry point into a \
          program (e.g. is a Fortran Program or a C main()).
:rtype: bool

Definition at line 235 of file routine.py.

     def is_program(self):
         '''
         :returns: whether this Routine represents the entry point into a \
                   program (e.g. is a Fortran Program or a C main()).
         :rtype: bool
         '''
         return self._is_program
  

References psyclone.psyir.nodes.routine.Routine._is_program.

Here is the caller graph for this function:

◆ name() [1/2]

def psyclone.psyir.nodes.routine.Routine.name ( self )

:returns: the name of this Routine.
:rtype: str

Definition at line 172 of file routine.py.

     def name(self):
         '''
         :returns: the name of this Routine.
         :rtype: str
         '''
         return self._name
  

References psyclone.domain.common.algorithm.psyir.AlgorithmInvokeCall._name, psyclone.domain.gocean.kernel.psyir.GOceanKernelMetadata._name, psyclone.domain.gocean.kernel.psyir.GOceanKernelMetadata.GridArg._name, psyclone.domain.lfric.kernel.lfric_kernel_metadata.LFRicKernelMetadata._name, psyclone.dynamo0p3.DynFuncDescriptor03._name, psyclone.expression.NamedArg._name, psyclone.gocean1p0.GOKernelGridArgument._name, psyclone.gocean1p0.GOStencil._name, psyclone.nemo.NemoInvoke._name, psyclone.nemo.NemoPSy._name, psyclone.parse.algorithm.FileInfo._name, psyclone.parse.algorithm.InvokeCall._name, psyclone.parse.kernel.KernelProcedure._name, psyclone.parse.kernel.KernelType._name, psyclone.parse.module_info.ModuleInfo._name, psyclone.psyGen.PSy._name, psyclone.psyGen.Invoke._name, psyclone.psyGen.Kern._name, psyclone.psyGen.Argument._name, psyclone.psyir.nodes.container.Container._name, psyclone.psyir.nodes.routine.Routine._name, and psyclone.psyir.symbols.symbol.Symbol._name.

Here is the caller graph for this function:

◆ name() [2/2]

def psyclone.psyir.nodes.routine.Routine.name	(	self,
		new_name
	)

Sets a new name for the Routine.

TODO #1200 this node should only hold a reference to the corresponding
RoutineSymbol and get its name from there.

:param str new_name: new name for the Routine.

:raises TypeError: if new_name is not a string.
:raises KeyError: if there already is a different named symbol with \
    the 'own_routine_tag' in the symbol_table.

Definition at line 180 of file routine.py.

     def name(self, new_name):
         '''
         Sets a new name for the Routine.
  
         TODO #1200 this node should only hold a reference to the corresponding
         RoutineSymbol and get its name from there.
  
         :param str new_name: new name for the Routine.
  
         :raises TypeError: if new_name is not a string.
         :raises KeyError: if there already is a different named symbol with \
             the 'own_routine_tag' in the symbol_table.
  
         '''
         if not isinstance(new_name, str):
             raise TypeError(f"Routine name must be a str but got "
                             f"'{type(new_name).__name__}'")
         # TODO #1200 The name is duplicated in the _name attribute and the
         # symbol.name that there is in the local symbol table. This setter
         # updates both but note that a better solution is needed because
         # renaming the symbol_table symbol alone would make it inconsistent.
         if not self._name:
             # If the 'own_routine_symbol' tag already exist check that is
             # consistent with the given routine name.
             if 'own_routine_symbol' in self.symbol_table.tags_dict:
                 existing_symbol = self.symbol_table.lookup_with_tag(
                         'own_routine_symbol', scope_limit=self)
                 if existing_symbol.name.lower() == new_name.lower():
                     self._name = new_name
                     return  # The preexisting symbol already matches
                 # Otherwise raise an exception
                 raise KeyError(
                     f"Can't assign '{new_name}' as the routine name because "
                     f"its symbol table contains a symbol ({existing_symbol}) "
                     f"already tagged as 'own_routine_symbol'.")
  
             self._name = new_name
             # Since the constructor can not mark methods as functions directly
             # the symbol will always start being NoType and must be updated
             # if a return_value type is provided.
             self.symbol_table.add(RoutineSymbol(new_name, NoType()),
                                   tag='own_routine_symbol')
         elif self._name != new_name:
             symbol = self.symbol_table.lookup(self._name)
             self._name = new_name
             self.symbol_table.rename_symbol(symbol, new_name)
  

Here is the call graph for this function:

Here is the caller graph for this function:

◆ node_str()

def psyclone.psyir.nodes.routine.Routine.node_str	(	self,
		colour = `True`
	)

 Returns the name of this node with (optional) control codes
to generate coloured output in a terminal that supports it.

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

:returns: description of this node, possibly coloured.
:rtype: str

Reimplemented from psyclone.psyir.nodes.node.Node.

Definition at line 152 of file routine.py.

     def node_str(self, colour=True):
         ''' Returns the name of this node with (optional) control codes
         to generate coloured output in a terminal that supports it.
  
         :param bool colour: whether or not to include colour control codes.
  
         :returns: description of this node, possibly coloured.
         :rtype: str
         '''
         return self.coloured_name(colour) + "[name:'" + self.name + "']"
  

Here is the call graph for this function:

Here is the caller graph for this function:

◆ return_symbol() [1/2]

def psyclone.psyir.nodes.routine.Routine.return_symbol ( self )

:returns: the symbol which will hold the return value of this Routine \
          or None if the Routine is not a function.
:rtype: :py:class:`psyclone.psyir.symbols.DataSymbol` or NoneType

Definition at line 244 of file routine.py.

     def return_symbol(self):
         '''
         :returns: the symbol which will hold the return value of this Routine \
                   or None if the Routine is not a function.
         :rtype: :py:class:`psyclone.psyir.symbols.DataSymbol` or NoneType
         '''
         return self._return_symbol
  

References psyclone.psyir.nodes.routine.Routine._return_symbol.

Here is the caller graph for this function:

◆ return_symbol() [2/2]

def psyclone.psyir.nodes.routine.Routine.return_symbol	(	self,
		value
	)

Setter for the return-symbol of this Routine node.

:param value: the symbol holding the value that the routine returns.
:type value: :py:class:`psyclone.psyir.symbols.DataSymbol`

:raises TypeError: if the supplied value is not a DataSymbol.
:raises KeyError: if the supplied symbol is not a local entry in the \
                  symbol table of this Routine.

Definition at line 253 of file routine.py.

     def return_symbol(self, value):
         '''
         Setter for the return-symbol of this Routine node.
  
         :param value: the symbol holding the value that the routine returns.
         :type value: :py:class:`psyclone.psyir.symbols.DataSymbol`
  
         :raises TypeError: if the supplied value is not a DataSymbol.
         :raises KeyError: if the supplied symbol is not a local entry in the \
                           symbol table of this Routine.
         '''
         if not isinstance(value, DataSymbol):
             raise TypeError(f"Routine return-symbol should be a DataSymbol "
                             f"but found '{type(value).__name__}'.")
         if value not in self.symbol_table.datasymbols:
             raise KeyError(
                 f"For a symbol to be a return-symbol, it must be present in "
                 f"the symbol table of the Routine but '{value.name}' is not.")
         self._return_symbol = value
         # The routine symbol must be updated accordingly, this is because the
         # function datatype is provided by the type of the return symbol which
         # may be given after the Routine is created.
         self.symbol_table.lookup(self._name).datatype = value.datatype
  

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/psyir/nodes/routine.py

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ __eq__()

◆ create()

◆ dag_name()

◆ is_program()

◆ name() [1/2]

◆ name() [2/2]

◆ node_str()

◆ return_symbol() [1/2]

◆ return_symbol() [2/2]

◆ eq()