compiler: fix linearization padding check

Author: mloubout

devito/finite_differences/interpolation.py

@@ -14,6 +14,8 @@ def interp_mapper(source, target, dims):
     """
     mapper = {}
     for d in dims:
+        if d.is_Time:
+            continue
         try:
             s = source[d]
             t = target[d]

devito/finite_differences/tools.py

@@ -48,11 +48,11 @@ def adjoint(self, matvec):
 def check_input(func):
     @wraps(func)
     def wrapper(expr, *args, **kwargs):
-        try:
-            return S.Zero if expr.is_Number else func(expr, *args, **kwargs)
-        except Exception as e:
-            raise type(e)(f"Error while computing finite-difference for expr={expr}: "
-                          f"{e}") from e
+        # try:
+        return S.Zero if expr.is_Number else func(expr, *args, **kwargs)
+        # except Exception as e:
+        #     raise type(e)(f"Error while computing finite-difference for expr={expr}: "
+        #                   f"{e}") from e
     return wrapper
 
 

devito/passes/iet/linearization.py

@@ -70,19 +70,7 @@ def key1(f, d):
     if f.is_regular:
         # For paddable objects the following holds:
         # `same dim + same halo + same padding_dtype => same (auto-)padding`
-        if d is f.dimensions[-1]:
-            # Only the last dimension is padded
-            try:
-                if f.padding == f.mapped.padding:
-                    # Padding set from the mapped Function
-                    # e.g. from buffering or fft temp array
-                    pad_key = f.mapped.__padding_dtype__
-                else:
-                    pad_key = f.__padding_dtype__
-            except AttributeError:
-                pad_key = f.__padding_dtype__
-        else:
-            pad_key = None
+        pad_key = f.__padding_dtype__ if d is f.dimensions[-1] else None
 
         return (d, f._size_halo[d], pad_key)
     else:

devito/types/array.py

@@ -247,7 +247,37 @@ class MappedArrayMixin:
 
 
 class ArrayMapped(MappedArrayMixin, Array):
-    is_autopaddable = True
+
+    __rkwargs__ = Array.__rkwargs__ + ('mapped',)
+
+    def __init_finalize__(self, *args, **kwargs):
+        self._mapped = kwargs.get('mapped')
+        super().__init_finalize__(*args, **kwargs)
+
+    @property
+    def mapped(self):
+        return self._mapped
+
+    @property
+    def is_autopaddable(self):
+        if self.mapped is None:
+            return True
+        return self.mapped.is_autopaddable
+
+    @property
+    def __padding_dtype__(self):
+        if self.mapped is not None:
+            return self.mapped.__padding_dtype__
+        return super().__padding_dtype__
+
+    @cached_property
+    def _signature(self):
+        # Exclude `mapped` so buf-reuse can dedup buffers across distinct
+        # mapped Functions
+        ret = [type(self), self.indices]
+        attrs = set(self.__rkwargs__) - {'name', 'function', 'mapped'}
+        ret.extend(getattr(self, i) for i in attrs)
+        return frozenset(ret)
 
 
 class ArrayObject(ArrayBasic):

devito/types/misc.py

@@ -267,12 +267,6 @@ def __init_finalize__(self, *args, shift=None, **kwargs):
         # for homogeneity reasons
         self._shift = as_tuple(shift)
 
-    def __padding_setup__(self, **kwargs):
-        padding = kwargs.pop('padding', None)
-        if padding is None:
-            padding = self.__padding_setup_smart__(**kwargs)
-        return super().__padding_setup__(padding=padding, **kwargs)
-
     @property
     def shift(self):
         return self._shift