Inheritance diagram for psyclone.transformations.ACCDataTrans:

[legend]

Collaboration diagram for psyclone.transformations.ACCDataTrans:

[legend]

Public Member Functions
def	name (self)

def	apply (self, node, options=None)

def	validate (self, nodes, options)

Public Member Functions inherited from psyclone.psyir.transformations.region_trans.RegionTrans
def	get_node_list (self, nodes)

Static Public Attributes
tuple	excluded_node_types = (CodeBlock, Return, PSyDataNode)

Static Public Attributes inherited from psyclone.psyir.transformations.region_trans.RegionTrans
tuple	excluded_node_types = ()

Detailed Description

Add an OpenACC data region around a list of nodes in the PSyIR.
COPYIN, COPYOUT and COPY clauses are added as required.

For example:

>>> from psyclone.parse.algorithm import parse
>>> from psyclone.psyGen import PSyFactory
>>> api = "nemo"
>>> ast, invokeInfo = parse(NEMO_SOURCE_FILE, api=api)
>>> psy = PSyFactory(api).create(invokeInfo)
>>>
>>> from psyclone.transformations import ACCKernelsTrans, ACCDataTrans
>>> ktrans = ACCKernelsTrans()
>>> dtrans = ACCDataTrans()
>>>
>>> schedule = psy.invokes.get('tra_adv').schedule
>>> # Uncomment the following line to see a text view of the schedule
>>> # print(schedule.view())
>>>
>>> # Add a kernels construct for execution on the device
>>> kernels = schedule.children[9]
>>> ktrans.apply(kernels)
>>>
>>> # Enclose the kernels in a data construct
>>> kernels = schedule.children[9]
>>> dtrans.apply(kernels)

Definition at line 2710 of file transformations.py.

Member Function Documentation

◆ apply()

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

Put the supplied node or list of nodes within an OpenACC data region.

:param node: the PSyIR node(s) to enclose in the data region.
:type node: (list of) :py:class:`psyclone.psyir.nodes.Node`
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 2751 of file transformations.py.

     def apply(self, node, options=None):
         '''
         Put the supplied node or list of nodes within an OpenACC data region.
  
         :param node: the PSyIR node(s) to enclose in the data region.
         :type node: (list of) :py:class:`psyclone.psyir.nodes.Node`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
  
         '''
         # Ensure we are always working with a list of nodes, even if only
         # one was supplied via the `node` argument.
         node_list = self.get_node_list(node)
  
         self.validate(node_list, options)
  
         parent = node_list[0].parent
         start_index = node_list[0].position
  
         # Create a directive containing the nodes in node_list and insert it.
         directive = ACCDataDirective(
                 parent=parent, children=[node.detach() for node in node_list])
  
         parent.children.insert(start_index, directive)
  

Here is the call graph for this function:

◆ name()

def psyclone.transformations.ACCDataTrans.name ( self )

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

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 2743 of file transformations.py.

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

Here is the caller graph for this function:

◆ validate()

def psyclone.transformations.ACCDataTrans.validate	(	self,
		nodes,
		options
	)

Check that we can safely add a data region around the supplied list
of nodes.

:param nodes: the proposed node(s) to enclose in a data region.
:type nodes: List[:py:class:`psyclone.psyir.nodes.Node`] |
    :py:class:`psyclone.psyir.nodes.Node`
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]

:raises TransformationError: if the Schedule to which the nodes
    belong already has an 'enter data' directive.
:raises TransformationError: if any of the nodes are themselves
    data directives.
:raises TransformationError: if an array of structures needs to be
    deep copied (this is not currently supported).

Reimplemented from psyclone.psyir.transformations.region_trans.RegionTrans.

Definition at line 2776 of file transformations.py.

     def validate(self, nodes, options):
         # pylint: disable=signature-differs
         '''
         Check that we can safely add a data region around the supplied list
         of nodes.
  
         :param nodes: the proposed node(s) to enclose in a data region.
         :type nodes: List[:py:class:`psyclone.psyir.nodes.Node`] |
             :py:class:`psyclone.psyir.nodes.Node`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
  
         :raises TransformationError: if the Schedule to which the nodes
             belong already has an 'enter data' directive.
         :raises TransformationError: if any of the nodes are themselves
             data directives.
         :raises TransformationError: if an array of structures needs to be
             deep copied (this is not currently supported).
  
         '''
         # Ensure we are always working with a list of nodes, even if only
         # one was supplied via the `nodes` argument.
         node_list = self.get_node_list(nodes)
  
         super().validate(node_list, options)
  
         # Check that the Schedule to which the nodes belong does not already
         # have an 'enter data' directive.
         schedule = node_list[0].root
         acc_dirs = schedule.walk(ACCEnterDataDirective)
         if acc_dirs:
             raise TransformationError(
                 "Cannot add an OpenACC data region to a schedule that "
                 "already contains an 'enter data' directive.")
         # Check that we don't have any accesses to arrays of derived types
         # that we can't yet deep copy.
         for node in node_list:
             for sref in node.walk(StructureReference):
  
                 # Find the loop variables for all Loops that contain this
                 # access and are themselves within the data region.
                 loop_vars = []
                 cursor = sref.ancestor(Loop, limit=node)
                 while cursor:
                     loop_vars.append(Signature(cursor.variable.name))
                     cursor = cursor.ancestor(Loop)
  
                 # Now check whether any of these loop variables appear within
                 # the structure reference.
                 # Loop over each component of the structure reference that is
                 # an array access.
                 array_accesses = sref.walk(ArrayMixin)
                 for access in array_accesses:
                     if not isinstance(access, StructureMember):
                         continue
                     var_accesses = VariablesAccessInfo(access.indices)
                     for var in loop_vars:
                         if var not in var_accesses.all_signatures:
                             continue
                         # For an access such as my_struct(ii)%my_array(ji)
                         # then if we're inside a loop over it we would actually
                         # need a loop to do the deep copy:
                         #   do ii = 1, N
                         #   !$acc data copyin(my_struct(ii)%my_array)
                         #   end do
                         raise TransformationError(
                             f"Data region contains a structure access "
                             f"'{sref.debug_string()}' where component "
                             f"'{access.name}' is an array and is iterated over"
                             f" (variable '{var}'). Deep copying of data for "
                             f"structures is only supported where the deepest "
                             f"component is the one being iterated over.")
  
  

References psyclone.psyir.transformations.region_trans.RegionTrans.get_node_list().