compiler: Refine GuardExpr

Author: FabioLuporini

devito/ir/support/guards.py

@@ -277,11 +277,37 @@ def filter(self, key):
 
 class GuardExpr(LocalObject, BooleanFunction):
 
+    """
+    A boolean symbol that can be used as a guard. As such, it can be chained
+    with other relations using the standard boolean operators (&, |, ...).
+
+    Being a LocalObject, a GuardExpr may carry an `initvalue`, which is
+    the value that the guard assumes at the beginning of the scope where
+    it is defined.
+
+    Through the `supersets` argument, a GuardExpr may also carry a set of
+    GuardExprs that are known to be more restrictive than itself. This is
+    usesful, e.g., to avoid redundant checks when chaining multiple guards
+    together (see `simplify_and`).
+    """
+
     dtype = np.bool
 
-    def __init__(self, name, liveness='eager', **kwargs):
+    def __init__(self, name, liveness='eager', supersets=None, **kwargs):
         super().__init__(name, liveness=liveness, **kwargs)
 
+        self.supersets = frozenset(as_tuple(supersets))
+
+    def _hashable_content(self):
+        return super()._hashable_content() + (self.supersets,)
+
+    __hash__ = LocalObject.__hash__
+
+    def __eq__(self, other):
+        return (isinstance(other, GuardExpr) and
+                super().__eq__(other) and
+                self.supersets == other.supersets)
+
 
 # *** Utils
 
@@ -301,25 +327,30 @@ def simplify_and(relation, v):
     else:
         candidates, other = [], [relation, v]
 
+    # Quick check based on GuardExpr.supersets to avoid adding `v` to `relation`
+    # if `relation` already includes a more restrictive guard than `v`
+    if isinstance(v, GuardExpr):
+        if any(a in v.supersets for a in candidates):
+            return relation
+
     covered = False
     new_args = []
     for a in candidates:
         if isinstance(a, GuardExpr) or a.lhs is not v.lhs:
             new_args.append(a)
-            continue
-
-        covered = True
-        try:
-            if type(a) in (Gt, Ge) and v.rhs > a.rhs:
-                new_args.append(v)
-            elif type(a) in (Lt, Le) and v.rhs < a.rhs:
-                new_args.append(v)
-            else:
+        else:
+            covered = True
+            try:
+                if type(a) in (Gt, Ge) and v.rhs > a.rhs:
+                    new_args.append(v)
+                elif type(a) in (Lt, Le) and v.rhs < a.rhs:
+                    new_args.append(v)
+                else:
+                    new_args.append(a)
+            except TypeError:
+                # E.g., `v.rhs = const + z_M` and `a.rhs = z_M`, so the inequalities
+                # above are not evaluable to True/False
                 new_args.append(a)
-        except TypeError:
-            # E.g., `v.rhs = const + z_M` and `a.rhs = z_M`, so the inequalities
-            # above are not evaluable to True/False
-            new_args.append(a)
 
     if not covered:
         new_args.append(v)