compiler: Fix fission via logical dependence

Author: FabioLuporini

devito/ir/clusters/algorithms.py

@@ -228,17 +228,11 @@ 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:
-                    # If the same access pair is not a flow under logical distance,
-                    # the dep is a buffer/modulo-aliasing artifact and fission is OK
-                    ldist = dep.source.distance(dep.sink, logical=True)
-                    real_flow = (ldist > 0) or \
-                        (ldist == 0 and dep.sink.lex_ge(dep.source))
-                    if not real_flow:
-                        test0 = real_flow
                 if test0 or test1:
                     return False
 

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):
         """

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_dse.py

@@ -9,10 +9,10 @@
     get_params, skipif
 )
 from devito import (  # noqa
-    NODE, Abs, Buffer, ConditionalDimension, Constant, DefaultDimension, Derivative,
-    Dimension, Eq, Function, Ge, Grid, Inc, Lt, Operator, SparseTimeFunction,
-    SubDimension, TimeFunction, configuration, cos, dimensions, div, exp,
-    first_derivative, floor, grad, norm, sin, solve, sqrt, switchconfig, transpose
+    NODE, Abs, ConditionalDimension, Constant, DefaultDimension, Derivative, Dimension,
+    Eq, Function, Ge, Grid, Inc, Lt, Operator, SparseTimeFunction, SubDimension,
+    TimeFunction, configuration, cos, dimensions, div, exp, first_derivative, floor, grad,
+    norm, sin, solve, sqrt, switchconfig, transpose
 )
 from devito.exceptions import InvalidArgument, InvalidOperator
 from devito.ir import (
@@ -58,26 +58,6 @@ def test_scheduling_after_rewrite():
     assert all(trees[1].root.dim is tree.root.dim for tree in trees[1:])
 
 
-def test_scheduling_no_deriv():
-    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'
-    )
-
-
 @pytest.mark.parametrize('expr,expected', [
     ('2*fa[x] + fb[x]', '2*fa[x] + fb[x]'),
     ('fa[x]**2', 'fa[x]*fa[x]'),

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'
+    )