Inheritance diagram for psyclone.psyir.transformations.parallel_loop_trans.ParallelLoopTrans:

[legend]

Collaboration diagram for psyclone.psyir.transformations.parallel_loop_trans.ParallelLoopTrans:

[legend]

Public Member Functions
def	validate (self, node, options=None)

def	apply (self, node, options=None)

Public Member Functions inherited from psyclone.psyir.transformations.loop_trans.LoopTrans
def	name (self)

Static Public Attributes
tuple	excluded_node_types = (nodes.Return, psyGen.HaloExchange, nodes.CodeBlock)

Static Public Attributes inherited from psyclone.psyir.transformations.loop_trans.LoopTrans
tuple	excluded_node_types = ()

Detailed Description

Adds an abstract directive (it needs to be specified by sub-classing this
transformation) to a loop indicating that it should be parallelised. It
performs some data dependency checks to guarantee that the loop can be
parallelised without changing the semantics of it.

Definition at line 53 of file parallel_loop_trans.py.

Member Function Documentation

◆ apply()

def psyclone.psyir.transformations.parallel_loop_trans.ParallelLoopTrans.apply	(	self,
		node,
		options = `None`
	)

Apply the Loop transformation to the specified node in a
Schedule. This node must be a Loop since this transformation
corresponds to wrapping the generated code with directives,
e.g. for OpenMP:

.. code-block:: fortran

  !$OMP DO
  do ...
     ...
  end do
  !$OMP END DO

At code-generation time (when gen_code()` is called), this node must be
within (i.e. a child of) a PARALLEL region.

:param node: the supplied node to which we will apply the \
             Loop transformation.
:type node: :py:class:`psyclone.psyir.nodes.Node`
:param options: a dictionary with options for transformations. \
:type options: Optional[Dict[str, Any]]
:param int options["collapse"]: the number of loops to collapse into \
        single iteration space or None.

Reimplemented from psyclone.psyGen.Transformation.

Reimplemented in psyclone.transformations.Dynamo0p3OMPLoopTrans, psyclone.transformations.GOceanOMPParallelLoopTrans, psyclone.transformations.OMPParallelLoopTrans, psyclone.transformations.ACCLoopTrans, psyclone.transformations.OMPTaskloopTrans, psyclone.psyir.transformations.omp_task_trans.OMPTaskTrans, and psyclone.psyir.transformations.omp_loop_trans.OMPLoopTrans.

Definition at line 166 of file parallel_loop_trans.py.

     def apply(self, node, options=None):
         '''
         Apply the Loop transformation to the specified node in a
         Schedule. This node must be a Loop since this transformation
         corresponds to wrapping the generated code with directives,
         e.g. for OpenMP:
  
         .. code-block:: fortran
  
           !$OMP DO
           do ...
              ...
           end do
           !$OMP END DO
  
         At code-generation time (when gen_code()` is called), this node must be
         within (i.e. a child of) a PARALLEL region.
  
         :param node: the supplied node to which we will apply the \
                      Loop transformation.
         :type node: :py:class:`psyclone.psyir.nodes.Node`
         :param options: a dictionary with options for transformations. \
         :type options: Optional[Dict[str, Any]]
         :param int options["collapse"]: the number of loops to collapse into \
                 single iteration space or None.
  
         '''
         if not options:
             options = {}
         self.validate(node, options=options)
  
         collapse = options.get("collapse", None)
  
         # keep a reference to the node's original parent and its index as these
         # are required and will change when we change the node's location
         node_parent = node.parent
         node_position = node.position
  
         # Add our orphan loop directive setting its parent to the node's
         # parent and its children to the node. This calls down to the sub-class
         # to get the type of directive we require.
         directive = self._directive([node.detach()], collapse)
  
         # Add the loop directive as a child of the node's parent
         node_parent.addchild(directive, index=node_position)

◆ validate()

def psyclone.psyir.transformations.parallel_loop_trans.ParallelLoopTrans.validate	(	self,
		node,
		options = `None`
	)

Perform validation checks before applying the transformation

:param node: the node we are checking.
:type node: :py:class:`psyclone.psyir.nodes.Node`
:param options: a dictionary with options for transformations.\
                This transform supports "collapse", which is the\
                number of nested loops to collapse.
:type options: Optional[Dict[str, Any]]
:param int options["collapse"]: number of nested loops to collapse
                                or None.
:param bool options["force"]: whether to force parallelisation of the
        target loop (i.e. ignore any dependence analysis).
:param bool options["sequential"]: whether this is a sequential loop.

:raises TransformationError: if the \
        :py:class:`psyclone.psyir.nodes.Loop` loop iterates over \
        colours.
:raises TransformationError: if 'collapse' is supplied with an \
        invalid number of loops.
:raises TransformationError: if there is a data dependency that \
        prevents the parallelisation of the loop unless \
        `options["force"]` is True.

Reimplemented from psyclone.psyir.transformations.loop_trans.LoopTrans.

Reimplemented in psyclone.transformations.GOceanOMPLoopTrans, psyclone.transformations.Dynamo0p3OMPLoopTrans, psyclone.transformations.DynamoOMPParallelLoopTrans, and psyclone.psyir.transformations.omp_task_trans.OMPTaskTrans.

Definition at line 80 of file parallel_loop_trans.py.

     def validate(self, node, options=None):
         '''
         Perform validation checks before applying the transformation
  
         :param node: the node we are checking.
         :type node: :py:class:`psyclone.psyir.nodes.Node`
         :param options: a dictionary with options for transformations.\
                         This transform supports "collapse", which is the\
                         number of nested loops to collapse.
         :type options: Optional[Dict[str, Any]]
         :param int options["collapse"]: number of nested loops to collapse
                                         or None.
         :param bool options["force"]: whether to force parallelisation of the
                 target loop (i.e. ignore any dependence analysis).
         :param bool options["sequential"]: whether this is a sequential loop.
  
         :raises TransformationError: if the \
                 :py:class:`psyclone.psyir.nodes.Loop` loop iterates over \
                 colours.
         :raises TransformationError: if 'collapse' is supplied with an \
                 invalid number of loops.
         :raises TransformationError: if there is a data dependency that \
                 prevents the parallelisation of the loop unless \
                 `options["force"]` is True.
  
         '''
         # Check that the supplied node is a Loop and does not contain any
         # unsupported nodes.
         super().validate(node, options=options)
  
         if not options:
             options = {}
         collapse = options.get("collapse", None)
         ignore_dep_analysis = options.get("force", False)
         sequential = options.get("sequential", False)
  
         # Check we are not a sequential loop
         if (not sequential and isinstance(node, PSyLoop) and
                 node.loop_type == 'colours'):
             raise TransformationError(f"Error in {self.name} transformation. "
                                       f"The target loop is over colours and "
                                       f"must be computed serially.")
  
         # If 'collapse' is specified, check that it is an int and that the
         # loop nest has at least that number of loops in it
         if collapse:
             if not isinstance(collapse, int):
                 raise TransformationError(
                     f"The 'collapse' argument must be an integer but got an "
                     f"object of type {type(collapse)}")
             if collapse < 2:
                 raise TransformationError(
                     f"It only makes sense to collapse 2 or more loops "
                     f"but got a value of {collapse}")
             # Count the number of loops in the loop nest
             loop_count = 0
             cnode = node
             while isinstance(cnode, Loop):
                 loop_count += 1
                 # Loops must be tightly nested (no intervening statements)
                 cnode = cnode.loop_body[0]
             if collapse > loop_count:
                 raise TransformationError(
                     f"Cannot apply COLLAPSE({collapse}) clause to a loop nest "
                     f"containing only {loop_count} loops")
  
         # Check that there are no loop-carried dependencies
         if sequential or ignore_dep_analysis:
             return
  
         dep_tools = DependencyTools()
  
         if not node.independent_iterations(dep_tools=dep_tools,
                                            test_all_variables=True):
             # The DependencyTools also returns False for things that are
             # not an issue, so we ignore specific messages.
             for message in dep_tools.get_all_messages():
                 if message.code == DTCode.WARN_SCALAR_WRITTEN_ONCE:
                     continue
                 all_msg_str = [str(message) for message in
                                dep_tools.get_all_messages()]
                 messages = "\n".join(all_msg_str)
                 raise TransformationError(
                     f"Dependency analysis failed with the following "
                     f"messages:\n{messages}")
  

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

Public Member Functions

Static Public Attributes

Detailed Description

Member Function Documentation

◆ apply()

◆ validate()