compiler: support mutli-buffering

Author: mloubout

devito/ir/clusters/algorithms.py

@@ -259,10 +259,17 @@ def guard(clusters):
             # Separate out the indirect ConditionalDimensions, which only serve
             # the purpose of protecting from OOB accesses
             cds = [d for d in cds if not d.indirect]
+            modes = [cd.relation for cd in cds]
+            if modes.count('strict') > 1:
+                raise CompilationError("Only one `strict` condition"
+                                       "can be used in an equation")
+            elif 'strict' in modes:
+                mode = 'strict'
+            else:
+                mode = sympy.And if sympy.And in modes else sympy.Or
 
             # Chain together all `cds` conditions from all expressions in `c`
             guards = {}
-            mode = sympy.Or
             for cd in cds:
                 # `BOTTOM` parent implies a guard that lives outside of
                 # any iteration space, which corresponds to the placeholder None
@@ -279,7 +286,6 @@ def guard(clusters):
 
                 # Pull `cd` from any expr
                 condition = guards.setdefault(k, [])
-                mode = mode and cd.relation
                 for e in exprs:
                     try:
                         condition.append(e.conditionals[cd])
@@ -296,7 +302,10 @@ def guard(clusters):
 
             # Combination `mode` is And by default.
             # If all conditions are Or then Or combination `mode` is used.
-            guards = {d: mode(*v, evaluate=False) for d, v in guards.items()}
+            if mode == 'strict':
+                guards = {d: v[0] for d, v in guards.items()}
+            else:
+                guards = {d: mode(*v, evaluate=False) for d, v in guards.items()}
 
             # Construct a guarded Cluster
             processed.append(c.rebuild(exprs=exprs, guards=guards))

devito/ir/equations/equation.py

@@ -237,14 +237,6 @@ def __new__(cls, *args, **kwargs):
                     cond = d.relation(cond, GuardFactor(d))
                 conditionals[d] = cond
 
-        # Replace the ConditionalDimensions in `expr`
-        for d, cond in conditionals.items():
-            # Replace dimension with index
-            index = d.index
-            index = index - relational_min(cond, d.parent)
-            shift = relational_shift(cond, d.parent)
-            expr = uxreplace(expr, {d: IntDiv(index, d.symbolic_factor) + shift})
-
         # Merge conditionals when possible. E.g if we have an implicit_dim
         # and there is a dimension with the same parent, we ca merged
         # its condition
@@ -254,14 +246,22 @@ def __new__(cls, *args, **kwargs):
             for cd in dict(conditionals):
                 if cd.parent == d.parent and cd != d:
                     cond = conditionals.pop(d)
-                    mode = cd.relation and d.relation
-                    if issubclass(mode, sympy.Or):
-                        conditionals[d] = cond
-                        conditionals.pop(cd)
+                    if d.relation == 'strict':
+                        conditionals[cd] = conditionals[d] = cond
                     else:
+                        mode = cd.relation and d.relation
                         conditionals[cd] = mode(cond, conditionals[cd])
                     break
 
+        # Replace the ConditionalDimensions in `expr`
+        for d, cond in conditionals.items():
+            # Replace dimension with index
+            index = d.index
+            if d.condition is not None and d in expr.free_symbols:
+                index = index - relational_min(cond, d.parent)
+            shift = relational_shift(cond, d.parent)
+            expr = uxreplace(expr, {d: IntDiv(index, d.symbolic_factor) + shift})
+
         # Lower all Differentiable operations into SymPy operations
         rhs = diff2sympy(expr.rhs)
 

devito/ir/support/guards.py

@@ -13,7 +13,8 @@
 from sympy.logic.boolalg import BooleanFunction
 
 from devito.ir.support.space import Forward, IterationDirection
-from devito.symbolics import CondEq, CondNe, search
+from devito.symbolics import CondEq, CondNe, IntDiv, search
+from devito.symbolics.manipulation import _uxreplace_handle, _uxreplace_registry
 from devito.tools import Pickable, as_tuple, frozendict, split
 from devito.types import Dimension, LocalObject
 
@@ -31,6 +32,34 @@
 ]
 
 
+@singledispatch
+def bound_index(expr, dim, dir):
+    if dir == Forward:
+        return expr._subs(dim, dim + 1)
+    else:
+        return expr._subs(dim, dim - 1)
+
+
+@bound_index.register(Expr)
+def _(expr, dim, dir):
+    if not expr.args:
+        if dir == Forward:
+            return expr._subs(dim, dim + 1)
+        else:
+            return expr._subs(dim, dim - 1)
+    return expr.func(*[bound_index(a, dim, dir) for a in expr.args])
+
+
+@bound_index.register(IntDiv)
+def _(expr, dim, dir):
+    v = dim.symbolic_factor
+    p0 = dim.root
+    if dir == Forward:
+        return Mul((((p0 + 1) + v - 1) / v), v, evaluate=False)
+    else:
+        return (p0 - 1) - abs(p0 - 1) % v
+
+
 class AbstractGuard:
     pass
 
@@ -138,37 +167,29 @@ class BaseGuardBoundNext(Guard, Pickable):
     given `direction`.
     """
 
-    __rargs__ = ('d', 'direction')
+    __rargs__ = ('d', 'index', 'direction')
+    __rkwargs__ = ('d_min', 'd_max')
 
-    def __new__(cls, d, direction, **kwargs):
+    def __new__(cls, d, index, direction,
+                d_min=None, d_max=None, **kwargs):
         assert isinstance(d, Dimension)
         assert isinstance(direction, IterationDirection)
 
-        if direction == Forward:
-            p0 = d.root
-            p1 = d.root.symbolic_max
+        # Always take the next index in the iteration direction
+        next_index = bound_index(index, d, direction)
 
-            if d.is_Conditional:
-                v = d.symbolic_factor
-                # Round `p0 + 1` up to the nearest multiple of `v`
-                p0 = Mul((((p0 + 1) + v - 1) / v), v, evaluate=False)
-            else:
-                p0 = p0 + 1
+        # The direction might be forward but accessing c - d
+        # making the access backward w.r.t
+        # Update direction according to access direction for valid guard
+        if index.has(-d):
+            direction = -direction
 
+        if direction == Forward:
+            p0 = next_index
+            p1 = d_max or d.root.symbolic_max
         else:
-            p0 = d.root.symbolic_min
-            p1 = d.root
-
-            if d.is_Conditional:
-                v = d.symbolic_factor
-                # Round `p1 - 1` down to the nearest sub-multiple of `v`
-                # NOTE: we use ABS to make sure we handle negative values properly.
-                # Once `p1 - 1` is negative (e.g. `iteration=time - 1` and `time=0`),
-                # as long as we get a negative number, rather than 0 and even if it's
-                # not `-v`, we're good
-                p1 = (p1 - 1) - abs(p1 - 1) % v
-            else:
-                p1 = p1 - 1
+            p0 = d_min if d_min is not None else d.root.symbolic_min
+            p1 = next_index
 
         try:
             if cls.__base__._eval_relation(p0, p1) is true:
@@ -180,12 +201,15 @@ def __new__(cls, d, direction, **kwargs):
 
         obj.d = d
         obj.direction = direction
+        obj.index = index
+        obj.d_min = d_min
+        obj.d_max = d_max
 
         return obj
 
     @property
     def _args_rebuild(self):
-        return (self.d, self.direction)
+        return (self.d, self.index, self.direction)
 
 
 class GuardBoundNextLe(BaseGuardBoundNext, Le):
@@ -541,3 +565,11 @@ def pairwise_or(*guards):
             pass
 
     return guard
+
+
+_uxreplace_registry.register(BaseGuardBoundNext)
+
+
+@_uxreplace_handle.register(BaseGuardBoundNext)
+def _(expr, args, kwargs):
+    return expr.func(expr.d, expr.index, expr.direction, **kwargs)

devito/ir/support/space.py

@@ -601,6 +601,14 @@ def __repr__(self):
     def __hash__(self):
         return hash(self._name)
 
+    def __neg__(self):
+        if self._name == '++':
+            return Backward
+        elif self._name == '--':
+            return Forward
+        else:
+            return Any
+
 
 Forward = IterationDirection('++')
 """Forward iteration direction ('++')."""