Inheritance diagram for psyclone.transformations.ParallelRegionTrans:

[legend]

Collaboration diagram for psyclone.transformations.ParallelRegionTrans:

[legend]

Public Member Functions
def	__init__ (self)

def	__str__ (self)

def	validate (self, node_list, options=None)

def	apply (self, target_nodes, options=None)

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 = (CodeBlock, Return, psyGen.HaloExchange)

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

Detailed Description

Base class for transformations that create a parallel region.

Definition at line 1181 of file transformations.py.

Member Function Documentation

◆ apply()

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

Apply this transformation to a subset of the nodes within a
schedule - i.e. enclose the specified Loops in the
schedule within a single parallel region.

:param target_nodes: a single Node or a list of Nodes.
:type target_nodes: (list of) :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.

Reimplemented from psyclone.psyGen.Transformation.

Reimplemented in psyclone.transformations.ACCParallelTrans, and psyclone.transformations.OMPSingleTrans.

Definition at line 1234 of file transformations.py.

     def apply(self, target_nodes, options=None):
         # pylint: disable=arguments-renamed
         '''
         Apply this transformation to a subset of the nodes within a
         schedule - i.e. enclose the specified Loops in the
         schedule within a single parallel region.
  
         :param target_nodes: a single Node or a list of Nodes.
         :type target_nodes: (list of) :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.
  
         '''
  
         # 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 as a child of the
         # parent of the nodes being enclosed and with those nodes
         # as its children.
         # pylint: disable=not-callable
         directive = self._directive_factory(
             children=[node.detach() for node in node_list])
  
         # 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.ParallelRegionTrans.validate	(	self,
		node_list,
		options = `None`
	)

Check that the supplied list of Nodes are eligible to be
put inside a parallel region.

:param list node_list: list of nodes to put into a parallel region
:param options: a dictionary with options for transformations.\
:type options: Optional[Dict[str, Any]]
:param bool options["node-type-check"]: this flag controls whether \
    or not the type of the nodes enclosed in the region should be \
    tested to avoid using unsupported nodes inside a region.

:raises TransformationError: if the supplied node is an \
    InvokeSchedule rather than being within an InvokeSchedule.
:raises TransformationError: if the supplied nodes are not all \
    children of the same parent (siblings).

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

Reimplemented in psyclone.transformations.ACCParallelTrans, and psyclone.transformations.OMPParallelTrans.

Definition at line 1200 of file transformations.py.

     def validate(self, node_list, options=None):
         # pylint: disable=arguments-renamed
         '''
         Check that the supplied list of Nodes are eligible to be
         put inside a parallel region.
  
         :param list node_list: list of nodes to put into a parallel region
         :param options: a dictionary with options for transformations.\
         :type options: Optional[Dict[str, Any]]
         :param bool options["node-type-check"]: this flag controls whether \
             or not the type of the nodes enclosed in the region should be \
             tested to avoid using unsupported nodes inside a region.
  
         :raises TransformationError: if the supplied node is an \
             InvokeSchedule rather than being within an InvokeSchedule.
         :raises TransformationError: if the supplied nodes are not all \
             children of the same parent (siblings).
  
         '''
         if isinstance(node_list[0], InvokeSchedule):
             raise TransformationError(
                 f"A {self.name} transformation cannot be applied to an "
                 f"InvokeSchedule but only to one or more nodes from within an "
                 f"InvokeSchedule.")
  
         node_parent = node_list[0].parent
  
         for child in node_list:
             if child.parent is not node_parent:
                 raise TransformationError(
                     f"Error in {self.name} transformation: supplied nodes are "
                     f"not children of the same parent.")
         super().validate(node_list, options)
  

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

Static Public Attributes

Detailed Description

Member Function Documentation

◆ apply()

◆ validate()