compiler: Print an Array initializer through the ordinary printer path

An Array initializer already reached the printer, via `ccode` on a
`ListInitializer`; what it did not do was reach it at the Array's own
precision.  The elements were printed with the Operator's settings, so a
narrow Array sitting in an Operator whose arithmetic is left at the
default width had its entries emitted at the wider type.

Pass the Array's dtype to `ccode`, as `Expression` already does, rather
than route the initializer around the printer through an `initvalue`
hook of its own.  A target that needs to spell its literals differently
overrides `_print_ListInitializer`, which is the ordinary extension
point.

With the precision now correct at the point of printing, `_prec` no
longer needs to be told whether the arithmetic was narrowed on purpose:
a real literal takes the precision it is being printed at, and the
`float32` floor applies only where that is not itself a float.  That is
the same value as before for every dtype other than `float16`.

Author: mloubout

devito/core/operator.py

@@ -186,14 +186,6 @@ class BasicOperator(Operator):
     # ------------------------------------------------------------------
 
     INTERP_MODE = 'direct'
-
-    HALF_ARITH = False
-    """
-    Whether an Operator working in half precision carries the arithmetic there
-    too, rounding its literals and its FD weights to half. Off by default: half
-    is a storage format, and giving up the accuracy of the coefficients as well
-    is a mathematical choice rather than a consequence of it.
-    """
     """
     Default for the `sym_opt={'interp-mode': ...}` option. Controls how
     a product of fields living at different staggered locations is mapped
@@ -210,6 +202,12 @@ class BasicOperator(Operator):
     See `examples/userapi/08_staggered_interp.ipynb` for a worked example.
     """
 
+    HALF_ARITH = False
+    """
+    Whether an Operator working in half precision carries out the arithmetic there
+    too, rounding its literals and its FD weights to half. Off by default.
+    """
+
     @classmethod
     def _normalize_kwargs(cls, **kwargs):
         # Will be populated with dummy values; this method is actually overridden

devito/finite_differences/differentiable.py

@@ -1000,9 +1000,6 @@ def __eq__(self, other):
     __hash__ = sympy.Basic.__hash__
 
     def _hashable_content(self):
-        # NOTE: `dtype` belongs here. The same coefficients at two precisions
-        # are two different arrays, and leaving it out has one of them fetched
-        # from the cache in place of the other
         return (self.name, self.dimension, str(self.weights), self.scope,
                 np.dtype(self.dtype).name)
 

devito/ir/cgen/printer.py

@@ -43,12 +43,6 @@ class BasePrinter(CodePrinter):
     _func_literals = {}
     _prec_literals = {np.float32: 'F', np.complex64: 'F'}
 
-    # Whether the arithmetic is carried at the Operator's own precision, even
-    # where that is narrower than `float32`. Off by default: a narrow dtype is
-    # a storage choice, and it takes a deliberate one to also give up the
-    # accuracy of the literals
-    _half_arith = False
-
     _qualifiers_mapper = {
         'is_extern': 'extern',
         'is_const': 'const',
@@ -86,11 +80,11 @@ def _prec(self, expr):
         if dtype is None or np.issubdtype(dtype, np.integer):
             if any(isinstance(i, Float) for i in expr.atoms()):
                 # A real literal in an otherwise integer (or untyped)
-                # expression is emitted at the Operator's precision, floored at
-                # `float32` so that an integer default doesn't degrade it.
-                # A printer that has opted into narrow arithmetic keeps its own
-                # precision instead, rather than have the literal widen it
-                if self._half_arith and np.issubdtype(self.dtype, np.floating):
+                # expression takes the precision it is being printed at. The
+                # `float32` floor applies only where that precision is not
+                # itself a float, so that an integer default doesn't silently
+                # degrade the literal
+                if np.issubdtype(self.dtype, np.floating):
                     return self.dtype
                 try:
                     return np.promote_types(self.dtype, np.float32).type
@@ -386,17 +380,6 @@ def _print_FieldFromComposite(self, expr):
     def _print_ListInitializer(self, expr):
         return f"{{{', '.join(self._print(i) for i in expr.params)}}}"
 
-    def initvalue(self, init, dtype):
-        """
-        Print the aggregate initializer `init` of an Array of type `dtype`.
-
-        Kept separate from `_print_ListInitializer` because a static
-        initializer, unlike an expression, cannot rely on implicit conversions:
-        some types (e.g. CUDA's `__half`) are only constructible from a literal
-        via a runtime call, which is illegal in that position.
-        """
-        return self._print(init)
-
     def _print_IndexedPointer(self, expr):
         base = self._print(expr.base)
         return f"{base}{''.join(f'[{self._print(i)}]' for i in expr.index)}"

devito/ir/iet/visitors.py

@@ -360,21 +360,13 @@ def _gen_value(self, obj, mode=1, masked=()):
         if obj.is_Array and obj.initvalue is not None and mode == 1:
             init = ListInitializer(obj.initvalue)
             if not obj._mem_constant or init.is_numeric:
-                value = c.Initializer(value, self._gen_initvalue(obj, init))
+                # printed at the Array's own precision, not the Operator's
+                value = c.Initializer(value, self.ccode(init, dtype=obj.dtype))
         elif obj.is_LocalObject and obj.initvalue is not None and mode == 1:
             value = c.Initializer(value, self.ccode(obj.initvalue))
 
         return value
 
-    def _gen_initvalue(self, obj, init):
-        """
-        Convert the aggregate initializer `init` of the Array `obj` into a C
-        string, delegating to the printer so that languages whose types cannot
-        be built from plain literals (e.g. CUDA's `__half`) can specialize it.
-        """
-        printer = get_printer(self.printer, obj.dtype)
-        return printer.initvalue(init, obj.dtype)
-
     def _gen_rettype(self, obj):
         try:
             return self._gen_value(obj, 0).typename

devito/operator/operator.py

@@ -811,8 +811,8 @@ def _soname(self):
 
     @cached_property
     def _printer(self):
-        # A Target may offer a second printer for Operators that have opted
-        # into carrying their precision into the arithmetic
+        # A Target may offer a second printer e.g. for Operators
+        # using half-precision arithmetic
         if self._sym_options.get('half-arith'):
             with suppress(AttributeError):
                 return self._Target.HalfArithPrinter