Inheritance diagram for psyclone.domain.common.transformations.kernel_module_inline_trans.KernelModuleInlineTrans:

[legend]

Collaboration diagram for psyclone.domain.common.transformations.kernel_module_inline_trans.KernelModuleInlineTrans:

[legend]

Public Member Functions
def	__str__ (self)

def	validate (self, node, options=None)

def	apply (self, node, options=None)

Public Member Functions inherited from psyclone.psyGen.Transformation
def	name (self)

Detailed Description

 Module-inlines (bring the subroutine to the same compiler-unit) the
subroutine pointed by this Kernel. For example:

.. code-block:: python

    from psyclone.domain.common.transformations import \\
            KernelModuleInlineTrans

    inline_trans = KernelModuleInlineTrans()
    inline_trans.apply(schedule.walk(CodedKern)[0])

    print(schedule.parent.view())


.. warning ::
    Not all kernel subroutines can be module-inlined. This transformation
    will reject attempts to in-line kernels that access global data in the
    original module.

Definition at line 51 of file kernel_module_inline_trans.py.

Member Function Documentation

◆ apply()

def psyclone.domain.common.transformations.kernel_module_inline_trans.KernelModuleInlineTrans.apply	(	self,
		node,
		options = `None`
	)

 Bring the kernel subroutine into this Container.

:param node: the kernel to module-inline.
:type node: :py:class:`psyclone.psyGen.CodedKern`
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 250 of file kernel_module_inline_trans.py.

     def apply(self, node, options=None):
         ''' Bring the kernel subroutine into this Container.
  
         :param node: the kernel to module-inline.
         :type node: :py:class:`psyclone.psyGen.CodedKern`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
  
         '''
         self.validate(node, options)
  
         if not options:
             options = {}
  
         # Note that we use the resolved callee subroutine name and not the
         # caller one, this is important because if it is an interface it will
         # use the concrete implementation name. When this happens the new name
         # may already be in use, but the equality check below guarantees
         # that if it exists it is only valid when it references the exact same
         # implementation.
         code_to_inline = node.get_kernel_schedule()
         name = code_to_inline.name
  
         try:
             existing_symbol = node.scope.symbol_table.lookup(name)
         except KeyError:
             existing_symbol = None
  
         self._prepare_code_to_inline(code_to_inline)
  
         if not existing_symbol:
             # If it doesn't exist already, module-inline the subroutine by:
             # 1) Registering the subroutine symbol in the Container
             node.ancestor(Container).symbol_table.add(RoutineSymbol(
                     name, interface=DefaultModuleInterface()
             ))
             # 2) Insert the relevant code into the tree.
             node.ancestor(Container).addchild(code_to_inline.detach())
         else:
             # The routine symbol already exist, and we know from the validation
             # that its a Routine. Now check if they are exactly the same.
             for routine in node.ancestor(Container).walk(Routine,
                                                          stop_type=Routine):
                 if routine.name == node.name:
                     # This TransformationError happens here and not in the
                     # validation because it needs the symbols_to_bring_in
                     # applied to effectively compare both versions
                     # This will be fixed when module-inlining versioning is
                     # implemented.
                     if routine != code_to_inline:
                         raise TransformationError(
                             f"Cannot inline subroutine '{node.name}' because "
                             f"another, different, subroutine with the same "
                             f"name already exists and versioning of module-"
                             f"inlined subroutines is not implemented yet.")
  
         # We only modify the kernel call name after the equality check to
         # ensure the apply will succeed and we don't leave with an inconsistent
         # tree.
         if node.name.lower() != name:
             node.name = name
  
         # Set the module-inline flag to avoid generating the kernel imports
         # TODO #1823. If the kernel imports were generated at PSy-layer
         # creation time, we could just remove it here instead of setting a
         # flag.
         node.module_inline = True

Here is the call graph for this function:

◆ validate()

def psyclone.domain.common.transformations.kernel_module_inline_trans.KernelModuleInlineTrans.validate	(	self,
		node,
		options = `None`
	)

Checks that the supplied node is a Kernel and that it is possible to
inline its PSyIR.

:param kern: the kernel which is the target of the transformation.
:type kern: :py:class:`psyclone.psyGen.CodedKern`
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]

:raises TransformationError: if the target node is not a sub-class of \
    psyGen.CodedKern.
:raises TransformationError: if the subroutine containing the \
    implementation of the kernel cannot be retrieved with \
    'get_kernel_schedule'.
:raises TransformationError: if the name of the routine that \
    implements the kernel is not the same as the kernel name. This \
    will happen if the kernel is polymorphic (uses a Fortran \
    INTERFACE) and will be resolved by #1824.
:raises TransformationError: if the kernel cannot be safely inlined.

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 77 of file kernel_module_inline_trans.py.

     def validate(self, node, options=None):
         '''
         Checks that the supplied node is a Kernel and that it is possible to
         inline its PSyIR.
  
         :param kern: the kernel which is the target of the transformation.
         :type kern: :py:class:`psyclone.psyGen.CodedKern`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
  
         :raises TransformationError: if the target node is not a sub-class of \
             psyGen.CodedKern.
         :raises TransformationError: if the subroutine containing the \
             implementation of the kernel cannot be retrieved with \
             'get_kernel_schedule'.
         :raises TransformationError: if the name of the routine that \
             implements the kernel is not the same as the kernel name. This \
             will happen if the kernel is polymorphic (uses a Fortran \
             INTERFACE) and will be resolved by #1824.
         :raises TransformationError: if the kernel cannot be safely inlined.
  
         '''
         if not isinstance(node, CodedKern):
             raise TransformationError(
                 f"Target of a {self.name} must be a sub-class of "
                 f"psyGen.CodedKern but got '{type(node).__name__}'")
  
         # Check that the PSyIR and associated Symbol table of the Kernel is OK.
         # If this kernel contains symbols that are not captured in the PSyIR
         # SymbolTable then this raises an exception.
         try:
             kernel_schedule = node.get_kernel_schedule()
         except Exception as error:
             raise TransformationError(
                 f"{self.name} failed to retrieve PSyIR for kernel "
                 f"'{node.name}' using the 'get_kernel_schedule' method"
                 f" due to {error}."
                 ) from error
  
         # We do not support kernels that use symbols representing global
         # variables declared in its own parent module (we would need to
         # create new imports to this module for those, and we don't do
         # this yet).
         # These can only be found in References, Calls and CodeBlocks
         for var in kernel_schedule.walk(Reference):
             symbol = var.symbol
             if isinstance(symbol, IntrinsicSymbol):
                 continue
             if not symbol.is_import:
                 try:
                     var.scope.symbol_table.lookup(
                         symbol.name, scope_limit=kernel_schedule)
                 except KeyError as err:
                     raise TransformationError(
                         f"Kernel '{node.name}' contains accesses to "
                         f"'{symbol.name}' which is declared in the same "
                         f"module scope. Cannot inline such a kernel.") from err
         for block in kernel_schedule.walk(CodeBlock):
             for name in block.get_symbol_names():
                 try:
                     block.scope.symbol_table.lookup(
                         name, scope_limit=kernel_schedule)
                 except KeyError as err:
                     if not block.scope.symbol_table.lookup(name).is_import:
                         raise TransformationError(
                             f"Kernel '{node.name}' contains accesses to "
                             f"'{name}' in a CodeBlock that is declared in the "
                             f"same module scope. "
                             f"Cannot inline such a kernel.") from err
  
         # We can't transform subroutines that shadow top-level symbol module
         # names, because we won't be able to bring this into the subroutine
         symtab = kernel_schedule.ancestor(Container).symbol_table
         for scope in kernel_schedule.walk(ScopingNode):
             for symbol in scope.symbol_table.symbols:
                 for mod in symtab.containersymbols:
                     if symbol.name == mod.name and not \
                             isinstance(symbol, ContainerSymbol):
                         raise TransformationError(
                             f"Kernel '{node.name}' cannot be module-inlined"
                             f" because the subroutine shadows the symbol "
                             f"name of the module container '{symbol.name}'.")
  
         # If the symbol already exist at the call site it must be referring
         # to a Routine
         try:
             existing_symbol = node.scope.symbol_table.lookup(node.name)
         except KeyError:
             existing_symbol = None
         if existing_symbol and not isinstance(existing_symbol, RoutineSymbol):
             raise TransformationError(
                 f"Cannot module-inline subroutine '{node.name}' because "
                 f"symbol '{existing_symbol}' with the same name already "
                 f"exists and changing the name of module-inlined "
                 f"subroutines is not supported yet.")
  

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/common/transformations/kernel_module_inline_trans.py

Public Member Functions

Detailed Description

Member Function Documentation

◆ apply()

◆ validate()