Inheritance diagram for psyclone.transformations.KernelImportsToArguments:

[legend]

Collaboration diagram for psyclone.transformations.KernelImportsToArguments:

[legend]

Public Member Functions
def	name (self)

def	__str__ (self)

def	validate (self, node, options=None)

def	apply (self, node, options=None)

Detailed Description

Transformation that removes any accesses of imported data from the supplied
kernel and places them in the caller. The values/references are then passed
by argument into the kernel.

Definition at line 2850 of file transformations.py.

Member Function Documentation

◆ apply()

def psyclone.transformations.KernelImportsToArguments.apply	(	self,
		node,
		options = `None`
	)

Convert the imported variables used inside the kernel into arguments
and modify the InvokeSchedule to pass the same imported variables to
the kernel call.

:param node: a kernel call.
: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 2916 of file transformations.py.

     def apply(self, node, options=None):
         '''
         Convert the imported variables used inside the kernel into arguments
         and modify the InvokeSchedule to pass the same imported variables to
         the kernel call.
  
         :param node: a kernel call.
         :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)
  
         kernel = node.get_kernel_schedule()
         symtab = kernel.symbol_table
         invoke_symtab = node.ancestor(InvokeSchedule).symbol_table
         count_imported_vars_removed = 0
  
         # Transform each imported variable into an argument.
         # TODO #11: When support for logging is added, we could warn the user
         # if no imports are found in the kernel.
         for imported_var in kernel.symbol_table.imported_symbols[:]:
             count_imported_vars_removed += 1
  
             # Resolve the data type information if it is not available
             # pylint: disable=unidiomatic-typecheck
             if (type(imported_var) is Symbol or
                     isinstance(imported_var.datatype, UnresolvedType)):
                 updated_sym = imported_var.resolve_type()
                 # If we have a new symbol then we must update the symbol table
                 if updated_sym is not imported_var:
                     kernel.symbol_table.swap(imported_var, updated_sym)
             # pylint: enable=unidiomatic-typecheck
  
             # Copy the imported symbol into the InvokeSchedule SymbolTable
             invoke_symtab.copy_external_import(
                 updated_sym, tag="AlgArgs_" + updated_sym.name)
  
             # Keep a reference to the original container so that we can
             # update it after the interface has been updated.
             container = updated_sym.interface.container_symbol
  
             # Convert the symbol to an argument and add it to the argument list
             current_arg_list = symtab.argument_list
             # An argument does not have an initial value.
             was_constant = updated_sym.is_constant
             updated_sym.is_constant = False
             updated_sym.initial_value = None
             if was_constant:
                 # Imported constants lose the constant value but are read-only
                 # TODO: When #633 and #11 are implemented, warn the user that
                 # they should transform the constants to literal values first.
                 updated_sym.interface = ArgumentInterface(
                     ArgumentInterface.Access.READ)
             else:
                 updated_sym.interface = ArgumentInterface(
                     ArgumentInterface.Access.READWRITE)
             current_arg_list.append(updated_sym)
             symtab.specify_argument_list(current_arg_list)
  
             # Convert PSyIR DataTypes to Gocean VALID_SCALAR_TYPES
             # TODO #678: Ideally this strings should be provided by the GOcean
             # API configuration.
             go_space = ""
             if updated_sym.datatype.intrinsic == ScalarType.Intrinsic.REAL:
                 go_space = "go_r_scalar"
             elif (updated_sym.datatype.intrinsic ==
                   ScalarType.Intrinsic.INTEGER):
                 go_space = "go_i_scalar"
             else:
                 raise TypeError(
                     f"The imported variable '{updated_sym.name}' could not be "
                     f"promoted to an argument because the GOcean "
                     f"infrastructure does not have any scalar type equivalent "
                     f"to the PSyIR {updated_sym.datatype} type.")
  
             # Add the imported variable in the call argument list
             node.arguments.append(updated_sym.name, go_space)
  
             # Check whether we still need the Container symbol from which
             # this import was originally accessed
             if not kernel.symbol_table.symbols_imported_from(container) and \
                not container.wildcard_import:
                 kernel.symbol_table.remove(container)
  
         if count_imported_vars_removed > 0:
             node.modified = True
  
  
 # For Sphinx AutoAPI documentation generation

Here is the call graph for this function:

◆ name()

def psyclone.transformations.KernelImportsToArguments.name ( self )

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

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 2857 of file transformations.py.

     def name(self):
         '''
         :returns: the name of this transformation.
         :rtype: str
         '''
         return "KernelImportsToArguments"
  

Here is the caller graph for this function:

◆ validate()

def psyclone.transformations.KernelImportsToArguments.validate	(	self,
		node,
		options = `None`
	)

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

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

:raises TransformationError: if the supplied node is not a CodedKern.
:raises TransformationError: if this transformation is not applied to \
    a Gocean API Invoke.
:raises TransformationError: if the supplied kernel contains wildcard \
    imports of symbols from one or more containers (e.g. a USE without\
    an ONLY clause in Fortran).

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 2869 of file transformations.py.

     def validate(self, node, options=None):
         '''
         Check that the supplied node is a valid target for this transformation.
  
         :param node: the PSyIR node to validate.
         :type node: :py:class:`psyclone.psyGen.CodedKern`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
  
         :raises TransformationError: if the supplied node is not a CodedKern.
         :raises TransformationError: if this transformation is not applied to \
             a Gocean API Invoke.
         :raises TransformationError: if the supplied kernel contains wildcard \
             imports of symbols from one or more containers (e.g. a USE without\
             an ONLY clause in Fortran).
         '''
         if not isinstance(node, CodedKern):
             raise TransformationError(
                 f"The {self.name} transformation can only be applied to "
                 f"CodedKern nodes but found '{type(node).__name__}' instead.")
  
         invoke_schedule = node.ancestor(InvokeSchedule)
         if not isinstance(invoke_schedule, GOInvokeSchedule):
             raise TransformationError(
                 f"The {self.name} transformation is currently only supported "
                 f"for the GOcean API but got an InvokeSchedule of type: "
                 f"'{type(invoke_schedule).__name__}'")
  
         # Check that there are no unqualified imports or undeclared symbols
         try:
             kernel = node.get_kernel_schedule()
         except SymbolError as err:
             raise TransformationError(
                 f"Kernel '{node.name}' contains undeclared symbol: "
                 f"{err.value}") from err
  
         symtab = kernel.symbol_table
         for container in symtab.containersymbols:
             if container.wildcard_import:
                 raise TransformationError(
                     f"Kernel '{node.name}' has a wildcard import of symbols "
                     f"from container '{container.name}'. This is not "
                     f"supported.")
  
         # TODO #649. Check for variables accessed by the kernel but declared
         # in an outer scope.
  

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

◆ apply()

◆ name()

◆ validate()