misc: Refactoring, tidy up, and caching bugfix

Author: EdCaunt

devito/ir/clusters/algorithms.py

@@ -176,7 +176,7 @@ def callback(self, clusters, prefix, backlog=None, known_break=None):
         # user-specified backward iteration before defaulting to forward to avoid a
         # gotcha by using the logical d_anti here.
         idir = {d: Backward for d in candidates
-                if d.root in scope.d_anti_logical.cause_logical}
+                if d.root in scope.d_anti_logical.cause}
         if maybe_break:
             idir.update({d: Forward for d in candidates if d.root in scope.d_flow.cause})
         # Default to forward for remaining dimensions

devito/ir/support/basic.py

@@ -569,10 +569,6 @@ def timestamp(self):
     def distance(self):
         return self.source.distance(self.sink)
 
-    @cached_property
-    def distance_logical(self):
-        return self.source.distance(self.sink, logical=True)
-
     @cached_property
     def _defined_findices(self):
         return frozenset(flatten(i._defines for i in self.findices))
@@ -663,19 +659,6 @@ def cause(self):
                 return i._defines
         return frozenset()
 
-    # TODO: Refactor this
-    @cached_property
-    def cause_logical(self):
-        """Return the findex causing the dependence."""
-        for i, j in zip(self.findices, self.distance_logical, strict=False):
-            try:
-                if j > 0:
-                    return i._defines
-            except TypeError:
-                # Conservatively assume this is an offending dimension
-                return i._defines
-        return frozenset()
-
     @cached_property
     def read(self):
         if self.is_flow:
@@ -806,16 +789,19 @@ def is_storage_related(self, dims=None):
         return False
 
 
+class LogicalDependence(Dependence):
+
+    @cached_property
+    def distance(self):
+        return self.source.distance(self.sink, logical=True)
+
+
 class DependenceGroup(set):
 
     @cached_property
     def cause(self):
         return frozenset().union(*[i.cause for i in self])
 
-    @cached_property
-    def cause_logical(self):
-        return frozenset().union(*[i.cause_logical for i in self])
-
     @cached_property
     def functions(self):
         """Return the DiscreteFunctions inducing a dependence."""
@@ -1135,21 +1121,20 @@ def d_flow(self):
         return DependenceGroup(self.d_flow_gen())
 
     @memoized_generator
-    def d_anti_gen(self, logical=False):
+    def d_anti_gen(self, depcls=Dependence):
         """Generate the anti (or "write-after-read") dependences."""
         for k, v in self.writes.items():
             for w in v:
                 for r in self.reads_smart_gen(k):
                     if any(not rule(r, w) for rule in self.rules):
                         continue
 
-                    dependence = Dependence(r, w)
+                    dependence = depcls(r, w)
 
                     if dependence.is_imaginary:
                         continue
 
-                    distance = dependence.distance_logical \
-                        if logical else dependence.distance
+                    distance = dependence.distance
 
                     try:
                         is_anti = distance > 0 or (r.lex_lt(w) and distance == 0)
@@ -1172,7 +1157,7 @@ def d_anti_logical(self):
         Anti (or "write-after-read") dependences using logical rather than true
         distances.
         """
-        return DependenceGroup(self.d_anti_gen(logical=True))
+        return DependenceGroup(self.d_anti_gen(depcls=LogicalDependence))
 
     @memoized_generator
     def d_output_gen(self):

devito/tools/memoization.py

@@ -142,15 +142,18 @@ class CacheInstancesMeta(type):
     def __init__(cls: type[InstanceType], *args) -> None:  # type: ignore
         super().__init__(*args)
 
-        # Register the cached type
+        # Register the cached type and eagerly create its cache, bound to its
+        # own constructor. Eager initialisation avoids a bug where a subclass
+        # would inherit (and reuse) a parent's cache via MRO lookup if the
+        # parent happened to be instantiated first.
         CacheInstancesMeta._cached_types.add(cls)
+        maxsize = cls._instance_cache_size
+        cls._instance_cache = lru_cache(maxsize=maxsize)(
+            super().__call__
+        )
 
     def __call__(cls: type[InstanceType],  # type: ignore
                  *args, **kwargs) -> InstanceType:
-        if cls._instance_cache is None:
-            maxsize = cls._instance_cache_size
-            cls._instance_cache = lru_cache(maxsize=maxsize)(super().__call__)
-
         args, kwargs = cls._preprocess_args(*args, **kwargs)
         return cls._instance_cache(*args, **kwargs)