compiler: make printer part of the target and differentiate C and CXX

Author: mloubout

devito/core/cpu.py

@@ -8,7 +8,8 @@
 from devito.passes.clusters import (Lift, blocking, buffering, cire, cse,
                                     factorize, fission, fuse, optimize_pows,
                                     optimize_hyperplanes)
-from devito.passes.iet import (CTarget, OmpTarget, avoid_denormals, linearize,
+from devito.passes.iet import (CTarget, CXXTarget, COmpTarget, CXXOmpTarget,
+                               avoid_denormals, linearize,
                                mpiize, hoist_prodders, relax_incr_dimensions,
                                check_stability)
 from devito.tools import timed_pass
@@ -244,7 +245,7 @@ def _normalize_kwargs(cls, **kwargs):
 
 class Cpu64CustomOperator(Cpu64OperatorMixin, CustomOperator):
 
-    _Target = OmpTarget
+    _Target = COmpTarget
 
     @classmethod
     def _make_dsl_passes_mapper(cls, **kwargs):
@@ -325,20 +326,20 @@ class Cpu64NoopCOperator(Cpu64NoopOperator):
 
 
 class Cpu64NoopOmpOperator(Cpu64NoopOperator):
-    _Target = OmpTarget
+    _Target = COmpTarget
 
 
 class Cpu64AdvCOperator(Cpu64AdvOperator):
     _Target = CTarget
 
 
 class Cpu64AdvOmpOperator(Cpu64AdvOperator):
-    _Target = OmpTarget
+    _Target = COmpTarget
 
 
 class Cpu64FsgCOperator(Cpu64FsgOperator):
     _Target = CTarget
 
 
 class Cpu64FsgOmpOperator(Cpu64FsgOperator):
-    _Target = OmpTarget
+    _Target = COmpTarget

devito/ir/__init__.py

@@ -2,3 +2,4 @@
 from devito.ir.equations import *  # noqa
 from devito.ir.clusters import *  # noqa
 from devito.ir.iet import *  # noqa
+from devito.ir.printer import *  # noqa

devito/ir/cgen/__init__.py

@@ -0,0 +1 @@
+from devito.ir.cgen.printer import *  # noqa

devito/symbolics/printer.py devito/ir/cgen/printer.pydevito/symbolics/printer.py renamed to devito/ir/cgen/printer.py

@@ -10,25 +10,22 @@
 from sympy.core import S
 from sympy.core.numbers import equal_valued, Float
 from sympy.printing.codeprinter import CodePrinter
-from sympy.printing.c import C99CodePrinter
-from sympy.printing.cxx import CXX11CodePrinter
 from sympy.logic.boolalg import BooleanFunction
 from sympy.printing.precedence import PRECEDENCE_VALUES, precedence
 
 from devito import configuration
 from devito.arch.compiler import AOMPCompiler
 from devito.symbolics.inspection import has_integer_args, sympy_dtype
-from devito.symbolics.extended_dtypes import c_complex, c_double_complex
 from devito.types.basic import AbstractFunction
 from devito.tools import ctypes_to_cstr, dtype_to_ctype
 
-__all__ = ['ccode']
+__all__ = ['BasePrinter', 'printer_registry', 'ccode']
 
 
 _prec_litterals = {np.float16: 'F16', np.float32: 'F', np.complex64: 'F'}
 
 
-class _DevitoPrinterBase(CodePrinter):
+class BasePrinter(CodePrinter):
 
     """
     Decorator for sympy.printing.ccode.CCodePrinter.
@@ -366,7 +363,7 @@ def _print_Fallback(self, expr):
 
 # Lifted from SymPy so that we go through our own `_print_math_func`
 for k in ('exp log sin cos tan ceiling floor').split():
-    setattr(_DevitoPrinterBase, '_print_%s' % k, _DevitoPrinterBase._print_math_func)
+    setattr(BasePrinter, '_print_%s' % k, BasePrinter._print_math_func)
 
 
 # Always parenthesize IntDiv and InlineIf within expressions
@@ -377,53 +374,10 @@ def _print_Fallback(self, expr):
 # Sympy 1.11 has introduced a bug in `_print_Add`, so we enforce here
 # to always use the correct one from our printer
 if Version(sympy.__version__) >= Version("1.11"):
-    setattr(sympy.printing.str.StrPrinter, '_print_Add', _DevitoPrinterBase._print_Add)
+    setattr(sympy.printing.str.StrPrinter, '_print_Add', BasePrinter._print_Add)
 
 
-class CDevitoPrinter(_DevitoPrinterBase, C99CodePrinter):
-
-    _default_settings = {**_DevitoPrinterBase._default_settings,
-                         **C99CodePrinter._default_settings}
-    _func_litterals = {np.float32: 'f', np.complex64: 'f'}
-    _func_prefix = {np.float32: 'f', np.float64: 'f',
-                    np.complex64: 'c', np.complex128: 'c'}
-
-    # These cannot go through _print_xxx because they are classes not
-    # instances
-    type_mappings = {**C99CodePrinter.type_mappings,
-                     c_complex: 'float _Complex',
-                     c_double_complex: 'double _Complex'}
-
-    def _print_ImaginaryUnit(self, expr):
-        return '_Complex_I'
-
-
-class CXXDevitoPrinter(_DevitoPrinterBase, CXX11CodePrinter):
-
-    _default_settings = {**_DevitoPrinterBase._default_settings,
-                         **CXX11CodePrinter._default_settings}
-    _ns = "std::"
-    _func_litterals = {}
-    _func_prefix = {np.float32: 'f', np.float64: 'f'}
-
-    # These cannot go through _print_xxx because they are classes not
-    # instances
-    type_mappings = {**CXX11CodePrinter.type_mappings,
-                     c_complex: 'std::complex<float>',
-                     c_double_complex: 'std::complex<double>'}
-
-    def _print_ImaginaryUnit(self, expr):
-        return f'1i{self.prec_literal(expr).lower()}'
-
-
-class AccDevitoPrinter(CXXDevitoPrinter):
-
-    pass
-
-
-printer_registry: dict[str, type[_DevitoPrinterBase]] = {
-    'C': CDevitoPrinter, 'CXX': CXXDevitoPrinter,
-    'openmp': CDevitoPrinter, 'openacc': AccDevitoPrinter}
+printer_registry: dict[str, type[BasePrinter]] = {'default': BasePrinter}
 
 
 def ccode(expr, language=None, **settings):
@@ -443,8 +397,5 @@ def ccode(expr, language=None, **settings):
         the input ``expr`` itself.
     """
     lang = language or configuration['language']
-    cpp = settings.get('compiler', configuration['compiler'])._cpp
-    if lang in ['C', 'openmp'] and cpp:
-        lang = 'CXX'
-    printer = printer_registry.get(lang, CDevitoPrinter)
+    printer = printer_registry.get(lang, BasePrinter)
     return printer(settings=settings).doprint(expr, None)

devito/operator/registry.py

@@ -26,7 +26,7 @@ class OperatorRegistry(OrderedDict, metaclass=Singleton):
     """
 
     _modes = ('noop', 'advanced', 'advanced-fsg')
-    _languages = ('C', 'openmp', 'openacc', 'cuda', 'hip', 'sycl')
+    _languages = ('C', 'CXX', 'openmp', 'openacc', 'cuda', 'hip', 'sycl')
     _accepted = _modes + tuple(product(_modes, _languages))
 
     def add(self, operator, platform, mode, language='C'):

devito/passes/iet/languages/C.py

@@ -1,7 +1,11 @@
-from devito.ir import Call
+import numpy as np
+from sympy.printing.c import C99CodePrinter
+
+from devito.ir import Call, BasePrinter, printer_registry
 from devito.passes.iet.definitions import DataManager
 from devito.passes.iet.orchestration import Orchestrator
 from devito.passes.iet.langbase import LangBB
+from devito.symbolics.extended_dtypes import c_complex, c_double_complex
 
 __all__ = ['CBB', 'CDataManager', 'COrchestrator']
 
@@ -31,3 +35,26 @@ class CDataManager(DataManager):
 
 class COrchestrator(Orchestrator):
     lang = CBB
+
+
+class CPrinter(BasePrinter, C99CodePrinter):
+
+    _default_settings = {**BasePrinter._default_settings,
+                         **C99CodePrinter._default_settings}
+    _func_litterals = {np.float32: 'f', np.complex64: 'f'}
+    _func_prefix = {np.float32: 'f', np.float64: 'f',
+                    np.complex64: 'c', np.complex128: 'c'}
+
+    # These cannot go through _print_xxx because they are classes not
+    # instances
+    type_mappings = {**C99CodePrinter.type_mappings,
+                     c_complex: 'float _Complex',
+                     c_double_complex: 'double _Complex'}
+
+    def _print_ImaginaryUnit(self, expr):
+        return '_Complex_I'
+
+
+printer_registry['C'] = CPrinter
+printer_registry['openmp'] = CPrinter
+printer_registry['Copenmp'] = CPrinter

devito/passes/iet/languages/CXX.py

@@ -1,5 +1,9 @@
-from devito.ir import Call, UsingNamespace
+import numpy as np
+from sympy.printing.cxx import CXX11CodePrinter
+
+from devito.ir import Call, UsingNamespace, BasePrinter, printer_registry
 from devito.passes.iet.langbase import LangBB
+from devito.symbolics.extended_dtypes import c_complex, c_double_complex
 
 __all__ = ['CXXBB']
 
@@ -61,3 +65,25 @@ class CXXBB(LangBB):
         'complex-namespace': [UsingNamespace('std::complex_literals')],
         'def-complex': std_arith,
     }
+
+
+class CXXPrinter(BasePrinter, CXX11CodePrinter):
+
+    _default_settings = {**BasePrinter._default_settings,
+                         **CXX11CodePrinter._default_settings}
+    _ns = "std::"
+    _func_litterals = {}
+    _func_prefix = {np.float32: 'f', np.float64: 'f'}
+
+    # These cannot go through _print_xxx because they are classes not
+    # instances
+    type_mappings = {**CXX11CodePrinter.type_mappings,
+                     c_complex: 'std::complex<float>',
+                     c_double_complex: 'std::complex<double>'}
+
+    def _print_ImaginaryUnit(self, expr):
+        return f'1i{self.prec_literal(expr).lower()}'
+
+
+printer_registry['CXX'] = CXXPrinter
+printer_registry['CXXopenmp'] = CXXPrinter

devito/passes/iet/languages/openacc.py

@@ -2,14 +2,15 @@
 
 from devito.arch import AMDGPUX, NVIDIAX
 from devito.ir import (Call, DeviceCall, DummyExpr, EntryFunction, List, Block,
-                       ParallelTree, Pragma, Return, FindSymbols, make_callable)
+                       ParallelTree, Pragma, Return, FindSymbols, make_callable,
+                       printer_registry)
 from devito.passes import needs_transfer, is_on_device
 from devito.passes.iet.definitions import DeviceAwareDataManager
 from devito.passes.iet.engine import iet_pass
 from devito.passes.iet.orchestration import Orchestrator
 from devito.passes.iet.parpragma import (PragmaDeviceAwareTransformer, PragmaLangBB,
                                          PragmaIteration, PragmaTransfer)
-from devito.passes.iet.languages.CXX import CXXBB
+from devito.passes.iet.languages.CXX import CXXBB, CXXPrinter
 from devito.passes.iet.languages.openmp import OmpRegion, OmpIteration
 from devito.symbolics import FieldFromPointer, Macro, cast_mapper
 from devito.tools import filter_ordered, UnboundTuple
@@ -263,3 +264,11 @@ def place_devptr(self, iet, **kwargs):
 
 class AccOrchestrator(Orchestrator):
     lang = AccBB
+
+
+class AccPrinter(CXXPrinter):
+
+    pass
+
+
+printer_registry['openacc'] = AccPrinter

devito/passes/iet/languages/targets.py

@@ -1,9 +1,10 @@
-from devito.passes.iet.languages.C import CDataManager, COrchestrator
+from devito.passes.iet.languages.C import CDataManager, COrchestrator, CPrinter
+from devito.passes.iet.languages.CXX import CXXPrinter
 from devito.passes.iet.languages.openmp import (SimdOmpizer, Ompizer, DeviceOmpizer,
                                                 OmpDataManager, DeviceOmpDataManager,
                                                 OmpOrchestrator, DeviceOmpOrchestrator)
 from devito.passes.iet.languages.openacc import (DeviceAccizer, DeviceAccDataManager,
-                                                 AccOrchestrator)
+                                                 AccOrchestrator, AccPrinter)
 from devito.passes.iet.instrument import instrument
 
 __all__ = ['CTarget', 'OmpTarget', 'DeviceOmpTarget', 'DeviceAccTarget']
@@ -13,6 +14,7 @@ class Target:
     Parizer = None
     DataManager = None
     Orchestrator = None
+    Printer = None
 
     @classmethod
     def lang(cls):
@@ -27,21 +29,52 @@ class CTarget(Target):
     Parizer = SimdOmpizer
     DataManager = CDataManager
     Orchestrator = COrchestrator
+    Printer = CPrinter
 
 
-class OmpTarget(Target):
+class CXXTarget(Target):
+    Parizer = SimdOmpizer
+    DataManager = CDataManager
+    Orchestrator = COrchestrator
+    Printer = CXXPrinter
+
+
+class COmpTarget(Target):
     Parizer = Ompizer
     DataManager = OmpDataManager
     Orchestrator = OmpOrchestrator
+    Printer = CPrinter
+
+
+OmpTarget = COmpTarget
+
+
+class CXXOmpTarget(Target):
+    Parizer = Ompizer
+    DataManager = OmpDataManager
+    Orchestrator = OmpOrchestrator
+    Printer = CXXPrinter
+
+
+class DeviceCOmpTarget(Target):
+    Parizer = DeviceOmpizer
+    DataManager = DeviceOmpDataManager
+    Orchestrator = DeviceOmpOrchestrator
+    Printer = CPrinter
+
+
+DeviceOmpTarget = DeviceCOmpTarget
 
 
-class DeviceOmpTarget(Target):
+class DeviceCXXOmpTarget(Target):
     Parizer = DeviceOmpizer
     DataManager = DeviceOmpDataManager
     Orchestrator = DeviceOmpOrchestrator
+    Printer = CXXPrinter
 
 
 class DeviceAccTarget(Target):
     Parizer = DeviceAccizer
     DataManager = DeviceAccDataManager
     Orchestrator = AccOrchestrator
+    Printer = AccPrinter

tests/test_dtypes.py

@@ -8,7 +8,7 @@
 from devito.passes.iet.languages.openacc import AccBB
 from devito.passes.iet.languages.openmp import OmpBB
 from devito.symbolics.extended_dtypes import ctypes_vector_mapper
-from devito.symbolics.printer import printer_registry, _DevitoPrinterBase
+from devito.symbolics.printer import printer_registry, BasePrinter
 from devito.types.basic import Basic, Scalar, Symbol
 from devito.types.dense import TimeFunction
 
@@ -27,7 +27,7 @@ def _get_language(language: str, **_) -> type[LangBB]:
     return _languages[language]
 
 
-def _get_printer(language: str, **_) -> type[_DevitoPrinterBase]:
+def _get_printer(language: str, **_) -> type[BasePrinter]:
     """
     Gets the printer building block type from parametrized kwargs.
     """
@@ -91,7 +91,7 @@ def test_cse_ctypes(dtype: np.dtype[np.inexact], kwargs: dict[str, str]) -> None
     the generated code.
     """
     # Retrieve the language-specific type mapping
-    printer: type[_DevitoPrinterBase] = _get_printer(**kwargs)
+    printer: type[BasePrinter] = _get_printer(**kwargs)
 
     # Set up an operator
     grid = Grid(shape=(3, 3))