Merge pull request #2909 from devitocodes/fix-break-clusters

compiler: catch corner case read after write

Author: FabioLuporini

devito/ir/clusters/algorithms.py

@@ -228,11 +228,12 @@ def _break_for_parallelism(self, scope, dim, timestamp):
                 # Would break a dependence on storage
                 return False
 
-            if any(dep.is_carried(i) for i in candidates):
+            if any(dep.as_logical.is_carried(i) for i in candidates):
+                # If, from a semantic viewpoint, `i` is a purely sequential
+                # Dimension, give up
                 test0 = dep.is_flow and dep.is_lex_negative
                 test1 = dep.is_anti and dep.is_lex_positive
                 if test0 or test1:
-                    # Would break a data dependence
                     return False
 
             test = test or (bool(dep.cause & candidates) and not dep.is_lex_equal)

devito/ir/equations/equation.py

@@ -30,6 +30,10 @@ class IREq(sympy.Eq, Pickable):
     __rargs__ = ('lhs', 'rhs')
     __rkwargs__ = ('ispace', 'conditionals', 'implicit_dims', 'operation')
 
+    def _hashable_content(self):
+        return (*super()._hashable_content(),
+                *tuple(getattr(self, i) for i in self.__rkwargs__))
+
     @property
     def is_Scalar(self):
         return self.lhs.is_Symbol
@@ -302,7 +306,7 @@ def __new__(cls, *args, **kwargs):
                     setattr(expr, f'_{i}', v)
             else:
                 expr._ispace = kwargs['ispace']
-                expr._conditionals = kwargs.get('conditionals', frozendict())
+                expr._conditionals = kwargs.get('conditionals', {})
                 expr._implicit_dims = input_expr.implicit_dims
                 expr._operation = Operation.detect(input_expr)
         elif len(args) == 2:
@@ -313,6 +317,10 @@ def __new__(cls, *args, **kwargs):
         else:
             raise ValueError(f"Cannot construct ClusterizedEq from args={str(args)} "
                              f"and kwargs={str(kwargs)}")
+
+        # Immutability (and thus hashability, etc)
+        expr._conditionals = frozendict(expr._conditionals)
+
         return expr
 
     func = IREq._rebuild

devito/ir/support/basic.py

@@ -698,6 +698,10 @@ def is_iaw(self):
     def is_reduction(self):
         return self.source.is_reduction or self.sink.is_reduction
 
+    @cached_property
+    def as_logical(self):
+        return LogicalDependence(self.source, self.sink)
+
     @memoized_meth
     def is_const(self, dim):
         """
@@ -1105,6 +1109,7 @@ def d_flow_gen(self):
                         continue
 
                     distance = dependence.distance
+
                     try:
                         is_flow = distance > 0 or (r.lex_ge(w) and distance == 0)
                     except TypeError:

devito/ir/support/utils.py

@@ -278,7 +278,7 @@ def detect_io(exprs, relax=False):
             if rule(f):
                 writes.append(f)
 
-    return filter_sorted(reads), filter_sorted(writes)
+    return tuple(filter_sorted(reads)), tuple(filter_sorted(writes))
 
 
 def pull_dims(exprs, flag=True):

tests/test_fission.py

@@ -2,8 +2,8 @@
 
 from conftest import assert_structure
 from devito import (
-    Buffer, Eq, Function, Grid, Inc, Operator, SubDimension, SubDomain, TimeFunction,
-    solve
+    NODE, Buffer, Eq, Function, Grid, Inc, Operator, SubDimension, SubDomain,
+    TimeFunction, solve
 )
 from devito.ir.iet import retrieve_iteration_tree
 from devito.ir.support.properties import PARALLEL
@@ -131,7 +131,7 @@ def test_issue_1921():
     assert np.all(g.data == g1.data)
 
 
-def test_buffer1_fissioning():
+def test_buffer1_v0():
     """
     Tests an edge case whereby inability to spot the equivalence of
     `f.forward`/`backward` and `f` when using `Buffer(1)` would cause
@@ -196,3 +196,23 @@ def define(self, dimensions):
     # Two loop nests: free-surface-like and update-like
     assert_structure(op, ['t,x,y,z', 't,x0_blk0,y0_blk0,x,y,z'],
                      't,x,y,z,x0_blk0,y0_blk0,x,y,z')
+
+
+def test_buffer1_v1():
+    grid = Grid((11, 11, 11))
+    x, y, z = grid.dimensions
+
+    image_vs = Function(name='image_vs', grid=grid, space_order=1, staggered=NODE)
+    p_back_xy = TimeFunction(name='p_back_xy', grid=grid, staggered=(x, y),
+                             space_order=4, time_order=1, save=Buffer(1))
+
+    eqns = [Eq(image_vs, p_back_xy + image_vs),
+            Eq(p_back_xy.backward, p_back_xy)]
+
+    op = Operator(eqns)
+
+    assert_structure(
+        op,
+        ['t,x0_blk0,y0_blk0,x,y,z', 't,x1_blk0,y1_blk0,x,y,z'],
+        'tx0_blk0y0_blk0xyzx1_blk0y1_blk0xyz'
+    )