Public Member Functions
def	__init__ (self, arg)

def	overlaps (self, arg)

def	reset_coverage (self)

def	update_coverage (self, arg)

def	covered (self)

Detailed Description

A helper class to simplify the determination of dependencies due to
overlapping accesses to data associated with instances of the
Argument class.

Definition at line 1973 of file psyGen.py.

Constructor & Destructor Documentation

◆ init()

def psyclone.psyGen.DataAccess.__init__	(	self,
		arg
	)

Store the argument associated with the instance of this class and
the Call, HaloExchange or GlobalSum (or a subclass thereof)
instance with which the argument is associated.

:param arg: the argument that we are concerned with. An \
argument can be found in a `Kern` a `HaloExchange` or a \
`GlobalSum` (or a subclass thereof)
:type arg: :py:class:`psyclone.psyGen.Argument`

Definition at line 1980 of file psyGen.py.

     def __init__(self, arg):
         '''Store the argument associated with the instance of this class and
         the Call, HaloExchange or GlobalSum (or a subclass thereof)
         instance with which the argument is associated.
  
         :param arg: the argument that we are concerned with. An \
         argument can be found in a `Kern` a `HaloExchange` or a \
         `GlobalSum` (or a subclass thereof)
         :type arg: :py:class:`psyclone.psyGen.Argument`
  
         '''
         # the `psyclone.psyGen.Argument` we are concerned with
         self._arg = arg
         # The call (Kern, HaloExchange, GlobalSum or subclass)
         # instance with which the argument is associated
         self._call = arg.call
         # initialise _covered and _vector_index_access to keep pylint
         # happy
         self._covered = None
         self._vector_index_access = None
         # Now actually set them to the required initial values
         self.reset_coverage()
  

References psyclone.gocean1p0.GOKernelArgument._arg, psyclone.psyGen.DataAccess._arg, psyclone.psyGen.KernelArgument._arg, psyclone.f2pygen.CallGen._call, psyclone.gocean1p0.GOKernelGridArgument._call, psyclone.psyGen.DataAccess._call, psyclone.psyGen.Argument._call, psyclone.psyGen.DataAccess._covered, psyclone.psyGen.DataAccess._vector_index_access, and psyclone.psyGen.DataAccess.reset_coverage().

Here is the call graph for this function:

Member Function Documentation

◆ covered()

def psyclone.psyGen.DataAccess.covered ( self )

Returns True if all of the data associated with this argument has
been covered by the arguments provided in update_coverage

:return bool: True if all of an argument is covered by \
previous accesses and False if not.

Definition at line 2115 of file psyGen.py.

     def covered(self):
         '''Returns True if all of the data associated with this argument has
         been covered by the arguments provided in update_coverage
  
         :return bool: True if all of an argument is covered by \
         previous accesses and False if not.
  
         '''
         return self._covered
  
  

References psyclone.psyGen.DataAccess._covered.

◆ overlaps()

def psyclone.psyGen.DataAccess.overlaps	(	self,
		arg
	)

Determine whether the accesses to the provided argument overlap
with the accesses of the source argument. Overlap means that
the accesses share at least one memory location. For example,
the arguments both access the 1st index of the same field.

We do not currently deal with accesses to a subset of an
argument (unless it is a vector). This distinction will need
to be added once loop splitting is supported.

:param arg: the argument to compare with our internal argument
:type arg: :py:class:`psyclone.psyGen.Argument`
:return bool: True if there are overlapping accesses between \
              arguments (i.e. accesses share at least one memory \
              location) and False if not.

Definition at line 2003 of file psyGen.py.

     def overlaps(self, arg):
         '''Determine whether the accesses to the provided argument overlap
         with the accesses of the source argument. Overlap means that
         the accesses share at least one memory location. For example,
         the arguments both access the 1st index of the same field.
  
         We do not currently deal with accesses to a subset of an
         argument (unless it is a vector). This distinction will need
         to be added once loop splitting is supported.
  
         :param arg: the argument to compare with our internal argument
         :type arg: :py:class:`psyclone.psyGen.Argument`
         :return bool: True if there are overlapping accesses between \
                       arguments (i.e. accesses share at least one memory \
                       location) and False if not.
  
         '''
         if self._arg.name != arg.name:
             # the arguments are different args so do not overlap
             return False
  
         if isinstance(self._call, HaloExchange) and \
            isinstance(arg.call, HaloExchange) and \
            (self._arg.vector_size > 1 or arg.vector_size > 1):
             # This is a vector field and both accesses come from halo
             # exchanges. As halo exchanges only access a particular
             # vector, the accesses do not overlap if the vector indices
             # being accessed differ.
  
             # sanity check
             if self._arg.vector_size != arg.vector_size:
                 raise InternalError(
                     f"DataAccess.overlaps(): vector sizes differ for field "
                     f"'{arg.name}' in two halo exchange calls. Found "
                     f"'{self._arg.vector_size}' and '{arg.vector_size}'")
             if self._call.vector_index != arg.call.vector_index:
                 # accesses are to different vector indices so do not overlap
                 return False
         # accesses do overlap
         return True
  

References psyclone.gocean1p0.GOKernelArgument._arg, psyclone.psyGen.DataAccess._arg, psyclone.psyGen.KernelArgument._arg, psyclone.f2pygen.CallGen._call, psyclone.gocean1p0.GOKernelGridArgument._call, psyclone.psyGen.DataAccess._call, and psyclone.psyGen.Argument._call.

Here is the caller graph for this function:

◆ reset_coverage()

def psyclone.psyGen.DataAccess.reset_coverage ( self )

Reset internal state to allow re-use of the object for a different
situation.

Definition at line 2044 of file psyGen.py.

     def reset_coverage(self):
         '''Reset internal state to allow re-use of the object for a different
         situation.
  
         '''
         # False unless all data accessed by our local argument has
         # also been accessed by other arguments.
         self._covered = False
         # Used to store individual vector component accesses when
         # checking that all vector components have been accessed.
         self._vector_index_access = []
  

References psyclone.psyGen.DataAccess._covered, and psyclone.psyGen.DataAccess._vector_index_access.

Here is the caller graph for this function:

◆ update_coverage()

def psyclone.psyGen.DataAccess.update_coverage	(	self,
		arg
	)

Record any overlap between accesses to the supplied argument and
the internal argument. Overlap means that the accesses to the
two arguments share at least one memory location. If the
overlap results in all of the accesses to the internal
argument being covered (either directly or as a combination
with previous arguments) then ensure that the covered() method
returns True. Covered means that all memory accesses by the
internal argument have at least one corresponding access by
the supplied arguments.

:param arg: the argument used to compare with our internal \
            argument in order to update coverage information
:type arg: :py:class:`psyclone.psyGen.Argument`

Definition at line 2056 of file psyGen.py.

     def update_coverage(self, arg):
         '''Record any overlap between accesses to the supplied argument and
         the internal argument. Overlap means that the accesses to the
         two arguments share at least one memory location. If the
         overlap results in all of the accesses to the internal
         argument being covered (either directly or as a combination
         with previous arguments) then ensure that the covered() method
         returns True. Covered means that all memory accesses by the
         internal argument have at least one corresponding access by
         the supplied arguments.
  
         :param arg: the argument used to compare with our internal \
                     argument in order to update coverage information
         :type arg: :py:class:`psyclone.psyGen.Argument`
  
         '''
  
         if not self.overlaps(arg):
             # There is no overlap so there is nothing to update.
             return
  
         if isinstance(arg.call, HaloExchange) and \
            (hasattr(self._arg, 'vector_size') and self._arg.vector_size > 1):
             # The supplied argument is a vector field coming from a
             # halo exchange and therefore only accesses one of the
             # vectors
  
             if isinstance(self._call, HaloExchange):
                 # I am also a halo exchange so only access one of the
                 # vectors. At this point the vector indices of the two
                 # halo exchange fields must be the same, which should
                 # never happen due to checks in the `overlaps()`
                 # method earlier
                 raise InternalError(
                     f"DataAccess:update_coverage() The halo exchange vector "
                     f"indices for '{self._arg.name}' are the same. This "
                     f"should never happen")
             else:
                 # I am not a halo exchange so access all components of
                 # the vector. However, the supplied argument is a halo
                 # exchange so only accesses one of the
                 # components. This results in partial coverage
                 # (i.e. the overlap in accesses is partial). Therefore
                 # record the index that is accessed and check whether
                 # all indices are now covered (which would mean `full`
                 # coverage).
                 if arg.call.vector_index in self._vector_index_access:
                     raise InternalError(
                         "DataAccess:update_coverage() Found more than one "
                         "dependent halo exchange with the same vector index")
                 self._vector_index_access.append(arg.call.vector_index)
                 if len(self._vector_index_access) != self._arg.vector_size:
                     return
         # This argument is covered i.e. all accesses by the
         # internal argument have a corresponding access in one of the
         # supplied arguments.
         self._covered = True
  

References psyclone.gocean1p0.GOKernelArgument._arg, psyclone.psyGen.DataAccess._arg, psyclone.psyGen.KernelArgument._arg, psyclone.f2pygen.CallGen._call, psyclone.gocean1p0.GOKernelGridArgument._call, psyclone.psyGen.DataAccess._call, psyclone.psyGen.Argument._call, psyclone.psyGen.DataAccess._covered, psyclone.psyGen.DataAccess._vector_index_access, and psyclone.psyGen.DataAccess.overlaps().