compiler: Switch from local to global autopadding

devito/passes/iet/linearization.py

@@ -71,12 +71,8 @@ def key1(f, d):
     """
     if f.is_regular:
         # For paddable objects the following holds:
-        # `same dim + same halo + same dtype => same (auto-)padding`
-        # Bundle need the actual function dtype
-        if f.is_Bundle:
-            return (d, f._size_halo[d], f.is_autopaddable, f.c0.dtype)
-        else:
-            return (d, f._size_halo[d], f.is_autopaddable, f.dtype)
+        # `same dim + same halo + same padding_dtype => same (auto-)padding`
+        return (d, f._size_halo[d], f.__padding_dtype__)
     else:
         return False
 

devito/types/array.py

@@ -367,6 +367,8 @@ def __args_setup__(cls, *args, **kwargs):
             raise ValueError("Components must be of same type")
         if not issubclass(klss.pop(), AbstractFunction):
             raise ValueError("Component type must be subclass of AbstractFunction")
+        if len({i.__padding_dtype__ for i in components}) != 1:
+            raise ValueError("Components must have the same padding dtype")
 
         return args, kwargs
 
@@ -438,14 +440,14 @@ def ncomp(self):
     def initvalue(self):
         return None
 
-    # CodeSymbol overrides defaulting to self.c0's behaviour
+    # Overrides defaulting to self.c0's behaviour
 
     for i in ['_mem_internal_eager', '_mem_internal_lazy', '_mem_local',
               '_mem_mapped', '_mem_host', '_mem_stack', '_mem_constant',
-              '_mem_shared', '_size_domain', '_size_halo', '_size_owned',
-              '_size_padding', '_size_nopad', '_size_nodomain', '_offset_domain',
-              '_offset_halo', '_offset_owned', '_dist_dimensions', '_C_get_field',
-              'grid', 'symbolic_shape']:
+              '_mem_shared', '__padding_dtype__', '_size_domain', '_size_halo',
+              '_size_owned', '_size_padding', '_size_nopad', '_size_nodomain',
+              '_offset_domain', '_offset_halo', '_offset_owned', '_dist_dimensions',
+              '_C_get_field', 'grid', 'symbolic_shape']:
         locals()[i] = property(lambda self, v=i: getattr(self.c0, v))
 
     @property

devito/types/basic.py

@@ -999,30 +999,41 @@ def __padding_setup__(self, **kwargs):
         padding = tuple(kwargs.get('padding', ((0, 0),)*self.ndim))
         return DimensionTuple(*padding, getters=self.dimensions)
 
+    @cached_property
+    def __padding_dtype__(self):
+        v = configuration['autopadding']
+        if not self.is_autopaddable or not v:
+            return None
+        try:
+            if issubclass(v, np.number):
+                return v
+        except TypeError:
+            return np.float32
+
     def __padding_setup_smart__(self, **kwargs):
         nopadding = ((0, 0),)*self.ndim
 
-        if kwargs.get('autopadding', configuration['autopadding']):
-            # The padded Dimension
-            candidates = self.space_dimensions
-            if not candidates:
-                return nopadding
-            d = candidates[-1]
-
-            mmts = configuration['platform'].max_mem_trans_size(self.dtype)
-            remainder = self._size_nopad[d] % mmts
-            if remainder == 0:
-                # Already a multiple of `mmts`, no need to pad
-                return nopadding
+        if not self.__padding_dtype__:
+            return nopadding
 
-            dpadding = (0, (mmts - remainder))
-            padding = [(0, 0)]*self.ndim
-            padding[self.dimensions.index(d)] = dpadding
+        # The padded Dimension
+        candidates = self.space_dimensions
+        if not candidates:
+            return nopadding
+        d = candidates[-1]
 
-            return tuple(padding)
-        else:
+        mmts = configuration['platform'].max_mem_trans_size(self.__padding_dtype__)
+        remainder = self._size_nopad[d] % mmts
+        if remainder == 0:
+            # Already a multiple of `mmts`, no need to pad
             return nopadding
 
+        dpadding = (0, (mmts - remainder))
+        padding = [(0, 0)]*self.ndim
+        padding[self.dimensions.index(d)] = dpadding
+
+        return tuple(padding)
+
     def __ghost_setup__(self, **kwargs):
         return (0, 0)
 

tests/test_linearize.py

@@ -611,4 +611,4 @@ def test_different_dtype():
 
     # Check generated code has different strides for different dtypes
     assert "bL0(x,y) b[(x)*y_stride0 + (y)]" in str(op1)
-    assert "L0(x,y) f[(x)*y_stride1 + (y)]" in str(op1)
+    assert "L0(x,y) f[(x)*y_stride0 + (y)]" in str(op1)