compiler: Tweaks to CTemp purging in CSE

Author: EdCaunt

devito/ir/clusters/algorithms.py

@@ -122,6 +122,7 @@ class Schedule(QueueStateful):
 
     @timed_pass(name='schedule')
     def process(self, clusters):
+        # from IPython import embed; embed()
         return self._process_fatd(clusters, 1)
 
     def callback(self, clusters, prefix, backlog=None, known_break=None):
@@ -156,6 +157,7 @@ def callback(self, clusters, prefix, backlog=None, known_break=None):
         # Schedule Clusters over different IterationSpaces if this increases
         # parallelism
         for i in range(1, len(clusters)):
+            # FIXME: This eats a lot of time (four seconds each time)
             if self._break_for_parallelism(scope, candidates, i):
                 return self.callback(clusters[:i], prefix, clusters[i:] + backlog,
                                      candidates | known_break)
@@ -191,6 +193,8 @@ def callback(self, clusters, prefix, backlog=None, known_break=None):
     def _break_for_parallelism(self, scope, candidates, i):
         # `test` will be True if there's at least one data-dependence that would
         # break parallelism
+
+        # TODO: Can this loop be made to short-circuit?
         test = False
         for d in scope.d_from_access_gen(scope.a_query(i)):
             if d.is_local or d.is_storage_related(candidates):

devito/ir/support/basic.py

@@ -363,6 +363,7 @@ 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
+                # TODO: This case represents the majority of time constructing a DAG
                 for v in (self[n], other[n]):
                     try:
                         if bool(v < sit.symbolic_min or v > sit.symbolic_max):
@@ -830,6 +831,7 @@ def __init__(self, exprs, rules=None):
         self.rules = as_tuple(rules)
         assert all(callable(i) for i in self.rules)
 
+    # FIXME: Should be put somewhere sensible
     @cached_property
     def thingy(self):
         return any(i.cause for i in self.d_anti_gen())

devito/operator/operator.py

@@ -967,8 +967,10 @@ def _emit_build_profiling(self):
         tot = timings.pop('op-compile')
         perf(f"Operator `{self.name}` generated in {fround(tot):.2f} s")
 
-        max_hotspots = 3
-        threshold = 20.
+        # max_hotspots = 3
+        # threshold = 20.
+        max_hotspots = 300
+        threshold = 0.5
 
         def _emit_timings(timings, indent=''):
             timings.pop('total', None)

devito/passes/clusters/cse.py

@@ -25,6 +25,8 @@ class CTemp(Temp):
     """
     A cluster-level Temp, similar to Temp, ensured to have different priority
     """
+    is_CTemp = True
+
     ordering_of_classes.insert(ordering_of_classes.index('Temp') + 1, 'CTemp')
 
 
@@ -220,13 +222,39 @@ def _compact(exprs, exclude):
     `for (i = ...) { a = b; for (j = a ...) ... }`. Hence, this routine
     only targets CTemps.
     """
+    # FIXME: Can use is_CTemp rather than isinstance
     candidates = [e for e in exprs
                   if isinstance(e.lhs, CTemp) and e.lhs not in exclude]
 
     mapper = {e.lhs: e.rhs for e in candidates if q_leaf(e.rhs)}
 
-    mapper.update({e.lhs: e.rhs for e in candidates
-                   if sum([i.rhs.count(e.lhs) for i in exprs]) == 1})
+    # FIXME: Move this to searches as retrieve_ctemps
+    from devito.symbolics.search import search
+
+    def q_ctemp(expr):
+        try:
+            return expr.is_CTemp
+        except AttributeError:
+            return False
+
+    # Find all the CTemps in expressions without removing duplicates
+    # ctemps = search(exprs, q_ctemp, 'all', 'dfs')
+    # I think it was more like
+    ctemps = search([e.rhs for e in exprs], q_ctemp, 'all', 'dfs')
+
+    # print(ctemps, len(ctemps), len(set(ctemps)), len(candidates))
+
+    # FIXME: This line is kinda slow. I should find some way to replace it.
+    # FIXME: Specifically sum([i.rhs.count(e.lhs) for i in exprs]) == 1 is slow as hell
+    # mapper.update({e.lhs: e.rhs for e in candidates
+    #                if sum([i.rhs.count(e.lhs) for i in exprs]) == 1})
+
+    # If there are ctemps in the expressions, then add any to the mapper which only
+    # appear once
+    # TODO: Double check this is exactly the prior behaviour?
+    if ctemps:
+        mapper.update({e.lhs: e.rhs for e in candidates
+                       if ctemps.count(e.lhs) == 1})
 
     processed = []
     for e in exprs:

devito/passes/clusters/misc.py

@@ -362,8 +362,7 @@ def is_cross(source, sink):
                 # (intuitively, "the loop nests are to be kept separated")
                 # * All ClusterGroups between `cg0` and `cg1` must precede `cg1`
                 # * All ClusterGroups after `cg1` cannot precede `cg1`
-                # FIXME: Attach to the scope
-                # if any(i.cause & prefix for i in scope.d_anti_gen()):
+                # FIXME: This is a terrible variable name
                 if prefix and scope.thingy:
                     for cg2 in cgroups[n:cgroups.index(cg1)]:
                         dag.add_edge(cg2, cg1)

devito/types/basic.py

@@ -298,6 +298,7 @@ class Basic(CodeSymbol):
     is_Object = False
     is_LocalObject = False
     is_LocalType = False
+    is_CTemp = False
 
     # Created by the user
     is_Input = False