compiler: Fix DDA with ComponentAccesses and whole-Bundle accesses

Author: FabioLuporini

devito/ir/support/basic.py

@@ -8,7 +8,8 @@
 from devito.ir.support.utils import AccessMode, extrema
 from devito.ir.support.vector import LabeledVector, Vector
 from devito.symbolics import (compare_ops, retrieve_indexed, retrieve_terminals,
-                              q_constant, q_affine, q_routine, search, uxreplace)
+                              q_constant, q_comp_acc, q_affine, q_routine, search,
+                              uxreplace)
 from devito.tools import (Tag, as_mapper, as_tuple, is_integer, filter_sorted,
                           flatten, memoized_meth, memoized_generator)
 from devito.types import (ComponentAccess, Dimension, DimensionTuple, Fence,
@@ -529,9 +530,16 @@ def __hash__(self):
             (self.source, self.sink, self.source.timestamp == self.sink.timestamp)
         )
 
-    @property
+    @cached_property
     def function(self):
-        return self.source.function
+        if q_comp_acc(self.source.access) and not q_comp_acc(self.sink.access):
+            # E.g., `source=ab[x].x` and `sink=ab[x]` -> `a(x)`
+            return self.source.access.function_access
+        elif q_comp_acc(self.sink.access) and not q_comp_acc(self.source.access):
+            # E.g., `source=ab[x]` and `sink=ab[x].y` -> `b(x)`
+            return self.sink.access.function_access
+        else:
+            return self.source.function
 
     @property
     def findices(self):
@@ -955,7 +963,7 @@ def reads_gen(self):
     @memoized_generator
     def reads_smart_gen(self, f):
         """
-        Generate all read access to a given function.
+        Generate all read accesses to a given function.
 
         StencilDimensions, if any, are replaced with their extrema.
 

devito/passes/iet/mpi.py

@@ -83,7 +83,6 @@ def _hoist_invariant(iet):
 
     for it, halo_spots in iter_mapper.items():
         for hs0, hs1 in combinations(halo_spots, r=2):
-
             if _check_control_flow(hs0, hs1, cond_mapper):
                 continue
 
@@ -129,10 +128,9 @@ def _hoist_invariant(iet):
 
 def _merge_halospots(iet):
     """
-    Merge HaloSpots on the same Iteration tree level where all data dependencies
-    would be honored. Avoids redundant halo exchanges when the same data is
-    redundantly exchanged within the same Iteration tree level as well as to initiate
-    multiple halo exchanges at once.
+    Using data dependence analysis, merge HaloSpots on the same IET level. This
+    has two effects: anticipating communication over computation, and (potentially)
+    avoiding redundant halo exchanges.
 
     Example:
 
@@ -141,7 +139,6 @@ def _merge_halospots(iet):
       W v[t1]- R v[t0]               W v[t1]- R v[t0]
       haloupd v[t0], h
       W g[t1]- R v[t0], h            W g[t1]- R v[t0], h
-
     """
 
     # Analysis
@@ -155,16 +152,15 @@ def _merge_halospots(iet):
         hs0 = halo_spots[0]
 
         for hs1 in halo_spots[1:]:
-
             if _check_control_flow(hs0, hs1, cond_mapper):
                 continue
 
             for f, v in hs1.fmapper.items():
                 for dep in scope.d_flow.project(f):
-                    if not any(r(dep, hs1, v.loc_indices) for r in rules):
+                    if not any(rule(dep, hs1, v.loc_indices) for rule in rules):
                         break
                 else:
-                    # hs1 is merged with hs0
+                    # All good -- `hs1` can be merged with `hs0`
                     hs = hs1.halo_scheme.project(f)
                     mapper[hs0] = HaloScheme.union([mapper.get(hs0, hs0.halo_scheme), hs])
                     mapper[hs1] = mapper.get(hs1, hs1.halo_scheme).drop(f)

devito/symbolics/queries.py

@@ -6,13 +6,14 @@
 from devito.types.basic import AbstractFunction
 from devito.types.constant import Constant
 from devito.types.dimension import Dimension
+from devito.types.array import ComponentAccess
 from devito.types.object import AbstractObject
 
 
 __all__ = ['q_leaf', 'q_indexed', 'q_terminal', 'q_function', 'q_routine',
            'q_terminalop', 'q_indirect', 'q_constant', 'q_affine', 'q_linear',
-           'q_identity', 'q_symbol', 'q_multivar', 'q_monoaffine', 'q_dimension',
-           'q_positive', 'q_negative']
+           'q_identity', 'q_symbol', 'q_comp_acc', 'q_multivar', 'q_monoaffine',
+           'q_dimension', 'q_positive', 'q_negative']
 
 
 # The following SymPy objects are considered tree leaves:
@@ -31,6 +32,10 @@ def q_symbol(expr):
         return False
 
 
+def q_comp_acc(expr):
+    return isinstance(expr, ComponentAccess)
+
+
 def q_leaf(expr):
     return (expr.is_Atom or
             expr.is_Indexed or

devito/types/array.py

@@ -611,6 +611,10 @@ def sindex(self):
     def function(self):
         return self.base.function
 
+    @property
+    def function_access(self):
+        return self.function.components[self.index]
+
     @property
     def indices(self):
         return self.base.indices

tests/test_ir.py

@@ -17,7 +17,7 @@
 from devito.ir.support.guards import GuardOverflow
 from devito.symbolics import DefFunction, FieldFromPointer
 from devito.tools import prod
-from devito.types import Array, CriticalRegion, Jump, Scalar, Symbol
+from devito.types import Array, Bundle, CriticalRegion, Jump, Scalar, Symbol
 
 
 class TestVectorHierarchy:
@@ -887,6 +887,32 @@ def test_critical_region_v1(self):
         assert len(scope.reads[mocksym1]) == 2
         assert len(scope.d_all) == 9
 
+    def test_bundle_components(self):
+        grid = Grid(shape=(4, 4))
+        x, y = grid.dimensions
+
+        f = Function(name='f', grid=grid)
+        g = Function(name='g', grid=grid)
+        v = Function(name='v', grid=grid)
+        w = Function(name='w', grid=grid)
+        u0 = Function(name='u0', grid=grid)
+        u1 = Function(name='u1', grid=grid)
+
+        fg = Bundle(name='fg', components=(f, g))
+        vw = Bundle(name='vw', components=(v, w))
+
+        exprs = [Eq(fg.indexify(), 1),
+                 Eq(u0.indexify(), fg[0, x, y] + 2),
+                 Eq(vw[0, x, y], 3),
+                 Eq(u1.indexify(), vw[1, x, y] + 4)]
+        exprs = [LoweredEq(i) for i in exprs]
+
+        scope = Scope(exprs)
+        assert len(scope.d_all) == 1
+        assert len(scope.d_flow) == 1
+        dep, = scope.d_flow
+        assert dep.function is f
+
 
 class TestParallelismAnalysis: