misc: Add comparisons that give up upon encountering symbolic arguments

Author: EdCaunt

devito/ir/support/basic.py

@@ -11,7 +11,8 @@
                               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)
+                          flatten, memoized_meth, memoized_generator, smart_gt,
+                          smart_lt)
 from devito.types import (ComponentAccess, Dimension, DimensionTuple, Fence,
                           CriticalRegion, Function, Symbol, Temp, TempArray,
                           TBArray)
@@ -317,9 +318,6 @@ def lex_le(self, other):
     def lex_lt(self, other):
         return self.timestamp < other.timestamp
 
-    # Note: memoization yields mild compiler speedup. Will need to be made
-    # thread-safe for multithreading the compiler.
-    @memoized_meth
     def distance(self, other):
         """
         Compute the distance from ``self`` to ``other``.
@@ -366,21 +364,14 @@ def distance(self, other):
                 # Case 1: `sit` is an IterationInterval with statically known
                 # trip count. E.g. it ranges from 0 to 3; `other` performs a
                 # constant access at 4
-
-                # To avoid evaluating expensive symbolic Lt or Gt operations,
-                # we pre-empt such operations by checking if the values to be compared
-                # to are symbolic, and skip this case if not.
-                if not any(isinstance(i, sympy.Basic)
-                           for i in (sit.symbolic_min, sit.symbolic_max)):
-
-                    for v in (self[n], other[n]):
-                        try:
-                            # Note: Boolean is split to make the conditional short
-                            # circuit more frequently for mild speedup
-                            if bool(v < sit.symbolic_min) or bool(v > sit.symbolic_max):
-                                return Vector(S.ImaginaryUnit)
-                        except TypeError:
-                            pass
+                for v in (self[n], other[n]):
+                    # Note: To avoid evaluating expensive symbolic Lt or Gt operations,
+                    # we pre-empt such operations by checking if the values to be compared
+                    # to are symbolic, and skip this case if not.
+                    # Note: Boolean is split to make the conditional short
+                    # circuit more frequently for mild speedup.
+                    if smart_lt(v, sit.symbolic_min) or smart_gt(v, sit.symbolic_max):
+                        return Vector(S.ImaginaryUnit)
 
                 # Case 2: `sit` is an IterationInterval over a local SubDimension
                 # and `other` performs a constant access

devito/tools/utils.py

@@ -12,7 +12,8 @@
            'roundm', 'powerset', 'invert', 'flatten', 'single_or', 'filter_ordered',
            'as_mapper', 'filter_sorted', 'pprint', 'sweep', 'all_equal', 'as_list',
            'indices_to_slices', 'indices_to_sections', 'transitive_closure',
-           'humanbytes', 'contains_val', 'sorted_priority', 'as_set', 'is_number']
+           'humanbytes', 'contains_val', 'sorted_priority', 'as_set', 'is_number',
+           'smart_lt', 'smart_gt']
 
 
 def prod(iterable, initial=1):
@@ -346,3 +347,32 @@ def key(i):
         return (v, str(type(i)))
 
     return sorted(items, key=key, reverse=True)
+
+
+def avoid_symbolic_relations(func):
+    """
+    Decorator to avoid calculating a relation symbolically if doing so may be slow.
+    In the case that one of the values being compared is symbolic, just give up
+    and return False.
+    """
+    def wrapper(a, b):
+        if any(isinstance(expr, sympy.Basic) for expr in (a, b)):
+            # An argument is symbolic, so give up and assume False
+            return False
+
+        try:
+            return func(a, b)
+        except TypeError:
+            return False
+
+    return wrapper
+
+
+@avoid_symbolic_relations
+def smart_lt(a, b):
+    return bool(a < b)
+
+
+@avoid_symbolic_relations
+def smart_gt(a, b):
+    return bool(a > b)