Inheritance diagram for psyclone.transformations.MarkRoutineForGPUMixin:

Public Member Functions
def	validate_it_can_run_on_gpu (self, node, options)

Detailed Description

 This Mixin provides the "validate_it_can_run_on_gpu" method that
given a routine or kernel node, it checks that the callee code is valid
to run on a GPU. It is implemented as a Mixin because transformations
from multiple programming models, e.g. OpenMP and OpenACC, can reuse
the same logic.

Definition at line 357 of file transformations.py.

Member Function Documentation

◆ validate_it_can_run_on_gpu()

def psyclone.transformations.MarkRoutineForGPUMixin.validate_it_can_run_on_gpu	(	self,
		node,
		options
	)

Check that the supplied node can be marked as available to be
called on GPU.

:param node: the kernel or routine to validate.
:type node: :py:class:`psyclone.psyGen.Kern` |
            :py:class:`psyclone.psyir.nodes.Routine`
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]
:param bool options["force"]: whether to allow routines with
    CodeBlocks to run on the GPU.

:raises TransformationError: if the node is not a kernel or a routine.
:raises TransformationError: if the target is a built-in kernel.
:raises TransformationError: if it is a kernel but without an
                             associated PSyIR.
:raises TransformationError: if any of the symbols in the kernel are
                             accessed via a module use statement.
:raises TransformationError: if the kernel contains any calls to other
                             routines.

Definition at line 365 of file transformations.py.

     def validate_it_can_run_on_gpu(self, node, options):
         '''
         Check that the supplied node can be marked as available to be
         called on GPU.
  
         :param node: the kernel or routine to validate.
         :type node: :py:class:`psyclone.psyGen.Kern` |
                     :py:class:`psyclone.psyir.nodes.Routine`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
         :param bool options["force"]: whether to allow routines with
             CodeBlocks to run on the GPU.
  
         :raises TransformationError: if the node is not a kernel or a routine.
         :raises TransformationError: if the target is a built-in kernel.
         :raises TransformationError: if it is a kernel but without an
                                      associated PSyIR.
         :raises TransformationError: if any of the symbols in the kernel are
                                      accessed via a module use statement.
         :raises TransformationError: if the kernel contains any calls to other
                                      routines.
         '''
         force = options.get("force", False) if options else False
  
         if not isinstance(node, (Kern, Routine)):
             raise TransformationError(
                 f"The {type(self).__name__} must be applied to a sub-class of "
                 f"Kern or Routine but got '{type(node).__name__}'.")
  
         # If it is a kernel call it must have an accessible implementation
         if isinstance(node, BuiltIn):
             raise TransformationError(
                 f"Applying {type(self).__name__} to a built-in kernel is not "
                 f"yet supported and kernel '{node.name}' is of type "
                 f"'{type(node).__name__}'")
  
         if isinstance(node, Kern):
             # Get the PSyIR routine from the associated kernel. If there is an
             # exception (this could mean that there is no associated tree
             # or that the frontend failed to convert it into PSyIR) reraise it
             # as a TransformationError
             try:
                 kernel_schedule = node.get_kernel_schedule()
             except Exception as error:
                 raise TransformationError(
                     f"Failed to create PSyIR for kernel '{node.name}'. "
                     f"Cannot transform such a kernel.") from error
             k_or_r = "Kernel"
         else:
             # Supplied node is a PSyIR Routine which *is* a Schedule.
             kernel_schedule = node
             k_or_r = "routine"
  
         # Check that the routine does not access any data that is imported via
         # a 'use' statement.
         # TODO #2271 - this implementation will not catch symbols from literal
         # precisions or intialisation expressions.
         refs = kernel_schedule.walk(Reference)
         for ref in refs:
             if ref.symbol.is_import:
                 # resolve_type does nothing if the Symbol type is known.
                 try:
                     ref.symbol.resolve_type()
                 except SymbolError:
                     # TODO #11 - log that we failed to resolve this Symbol.
                     pass
                 if (isinstance(ref.symbol, DataSymbol) and
                         ref.symbol.is_constant):
                     # An import of a compile-time constant is fine.
                     continue
                 raise TransformationError(
                     f"{k_or_r} '{node.name}' accesses the symbol "
                     f"'{ref.symbol}' which is imported. If this symbol "
                     f"represents data then it must first be converted to a "
                     f"{k_or_r} argument using the KernelImportsToArguments "
                     f"transformation.")
  
         # We forbid CodeBlocks because we can't be certain that what they
         # contain can be executed on a GPU. However, we do permit the user
         # to override this check.
         cblocks = kernel_schedule.walk(CodeBlock)
         if not force:
             if cblocks:
                 cblock_txt = ("\n  " + "\n  ".join(str(node) for node in
                                                    cblocks[0].get_ast_nodes)
                               + "\n")
                 option_txt = "options={'force': True}"
                 raise TransformationError(
                     f"Cannot safely apply {type(self).__name__} to {k_or_r} "
                     f"'{node.name}' because its PSyIR contains one or more "
                     f"CodeBlocks:{cblock_txt}You may use '{option_txt}' to "
                     f"override this check.")
         else:
             # Check any accesses within CodeBlocks.
             # TODO #2271 - this will be handled as part of the checking to be
             # implemented using the dependence analysis.
             for cblock in cblocks:
                 names = cblock.get_symbol_names()
                 for name in names:
                     sym = kernel_schedule.symbol_table.lookup(name)
                     if sym.is_import:
                         raise TransformationError(
                             f"{k_or_r} '{node.name}' accesses the symbol "
                             f"'{sym.name}' within a CodeBlock and this symbol "
                             f"is imported. {type(self).__name__} cannot be "
                             f"applied to such a {k_or_r}.")
  
         calls = kernel_schedule.walk(Call)
         for call in calls:
             if not call.is_available_on_device():
                 call_str = call.debug_string().rstrip("\n")
                 raise TransformationError(
                     f"{k_or_r} '{node.name}' calls another routine "
                     f"'{call_str}' which is not available on the "
                     f"accelerator device and therefore cannot have "
                     f"{type(self).__name__} applied to it (TODO #342).")
  
  

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

Public Member Functions

Detailed Description

Member Function Documentation

◆ validate_it_can_run_on_gpu()