Inheritance diagram for psyclone.transformations.ACCParallelTrans:

[legend]

Collaboration diagram for psyclone.transformations.ACCParallelTrans:

[legend]

Public Member Functions
def	__init__ (self, default_present=True)

def	__str__ (self)

def	validate (self, node_list, options=None)

def	apply (self, target_nodes, options=None)

Public Member Functions inherited from psyclone.transformations.ParallelRegionTrans
def	__init__ (self)

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

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

Static Public Attributes
tuple	excluded_node_types

Static Public Attributes inherited from psyclone.transformations.ParallelRegionTrans
tuple	excluded_node_types = (CodeBlock, Return, psyGen.HaloExchange)

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

Detailed Description

Create an OpenACC parallel region by inserting an 'acc parallel'
directive.

>>> from psyclone.psyGen import TransInfo
>>> from psyclone.psyir.frontend.fortran import FortranReader
>>> from psyclone.psyir.backend.fortran import FortranWriter
>>> from psyclone.psyir.nodes import Loop
>>> psyir = FortranReader().psyir_from_source("""
... program do_loop
...     real, dimension(10) :: A
...     integer i
...     do i = 1, 10
...       A(i) = i
...     end do
... end program do_loop
... """)
>>> ptrans = TransInfo().get_trans_name('ACCParallelTrans')
>>>
>>> # Enclose the loop within a OpenACC PARALLEL region
>>> ptrans.apply(psyir.walk(Loop))
>>> print(FortranWriter()(psyir))
program do_loop
  real, dimension(10) :: a
  integer :: i
<BLANKLINE>
  !$acc parallel default(present)
  do i = 1, 10, 1
    a(i) = i
  enddo
  !$acc end parallel
<BLANKLINE>
end program do_loop
<BLANKLINE>

Definition at line 1545 of file transformations.py.

Member Function Documentation

◆ apply()

def psyclone.transformations.ACCParallelTrans.apply	(	self,
		target_nodes,
		options = `None`
	)

Encapsulate given nodes with the ACCParallelDirective.

:param target_nodes: a single Node or a list of Nodes.
:type target_nodes: :py:class:`psyclone.psyir.nodes.Node` |
    List[:py:class:`psyclone.psyir.nodes.Node`]
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]
:param bool options["node-type-check"]: this flag controls if the
    type of the nodes enclosed in the region should be tested to
    avoid using unsupported nodes inside a region.
:param bool options["default_present"]: this flag controls if the
    inserted directive should include the default_present clause.

Reimplemented from psyclone.transformations.ParallelRegionTrans.

Definition at line 1622 of file transformations.py.

     def apply(self, target_nodes, options=None):
         '''
         Encapsulate given nodes with the ACCParallelDirective.
  
         :param target_nodes: a single Node or a list of Nodes.
         :type target_nodes: :py:class:`psyclone.psyir.nodes.Node` |
             List[:py:class:`psyclone.psyir.nodes.Node`]
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
         :param bool options["node-type-check"]: this flag controls if the
             type of the nodes enclosed in the region should be tested to
             avoid using unsupported nodes inside a region.
         :param bool options["default_present"]: this flag controls if the
             inserted directive should include the default_present clause.
  
         '''
         if not options:
             options = {}
         # Check whether we've been passed a list of nodes or just a
         # single node. If the latter then we create ourselves a
         # list containing just that node.
         node_list = self.get_node_list(target_nodes)
         self.validate(node_list, options)
  
         # Keep a reference to the parent of the nodes that are to be
         # enclosed within a parallel region. Also keep the index of
         # the first child to be enclosed as that will become the
         # position of the new !$omp parallel directive.
         node_parent = node_list[0].parent
         node_position = node_list[0].position
  
         # Create the parallel directive
         directive = ACCParallelDirective(
             children=[node.detach() for node in node_list])
         directive.default_present = options.get("default_present",
                                                 self._default_present)
  
         # Add the region directive as a child of the parent
         # of the nodes being enclosed and at the original location
         # of the first of these nodes
         node_parent.addchild(directive, index=node_position)
  
  

Here is the call graph for this function:

◆ validate()

def psyclone.transformations.ACCParallelTrans.validate	(	self,
		node_list,
		options = `None`
	)

Validate this transformation.

:param node_list: a single Node or a list of Nodes.
:type node_list: :py:class:`psyclone.psyir.nodes.Node` |
    List[:py:class:`psyclone.psyir.nodes.Node`]
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]
:param bool options["node-type-check"]: this flag controls if the
    type of the nodes enclosed in the region should be tested to
    avoid using unsupported nodes inside a region.
:param bool options["default_present"]: this flag controls if the
    inserted directive should include the default_present clause.

Reimplemented from psyclone.transformations.ParallelRegionTrans.

Definition at line 1598 of file transformations.py.

     def validate(self, node_list, options=None):
         '''
         Validate this transformation.
  
         :param node_list: a single Node or a list of Nodes.
         :type node_list: :py:class:`psyclone.psyir.nodes.Node` |
             List[:py:class:`psyclone.psyir.nodes.Node`]
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
         :param bool options["node-type-check"]: this flag controls if the
             type of the nodes enclosed in the region should be tested to
             avoid using unsupported nodes inside a region.
         :param bool options["default_present"]: this flag controls if the
             inserted directive should include the default_present clause.
  
         '''
         super().validate(node_list, options)
         if options is not None and "default_present" in options:
             if not isinstance(options["default_present"], bool):
                 raise TransformationError(
                     f"The provided 'default_present' option must be a "
                     f"boolean, but found '{options['default_present']}'."
                 )
  

Here is the caller graph for this function:

Member Data Documentation

◆ excluded_node_types

tuple psyclone.transformations.ACCParallelTrans.excluded_node_types

static

Initial value:

=  (CodeBlock, Return, PSyDataNode,
                           ACCDataDirective, ACCEnterDataDirective,
                           psyGen.HaloExchange)

Definition at line 1582 of file transformations.py.

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