compiler: add all cxx target to operator registry

Author: mloubout

devito/arch/compiler.py

@@ -180,7 +180,7 @@ def __init__(self):
     """
 
     fields = {'cc', 'ld'}
-    _cpp = False
+    default_cpp = False
 
     def __init__(self, **kwargs):
         _name = kwargs.pop('name', self.__class__.__name__)
@@ -191,6 +191,7 @@ def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
         self.__lookup_cmds__()
+        self._cpp = kwargs.get('cpp', self.default_cpp)
 
         self.suffix = kwargs.get('suffix')
         if not kwargs.get('mpi'):
@@ -200,7 +201,7 @@ def __init__(self, **kwargs):
             self.cc = self.MPICC if self._cpp is False else self.MPICXX
         self.ld = self.cc  # Wanted by the superclass
 
-        self.cflags = ['-O3', '-g', '-fPIC', '-Wall', '-std=c99']
+        self.cflags = ['-O3', '-g', '-fPIC', '-Wall', f'-std={self.std}']
         self.ldflags = ['-shared']
 
         self.include_dirs = []
@@ -252,6 +253,10 @@ def version(self):
 
         return version
 
+    @property
+    def std(self):
+        return 'c++14' if self._cpp else 'c99'
+
     def get_version(self):
         result, stdout, stderr = call_capture_output((self.cc, "--version"))
         if result != 0:
@@ -486,16 +491,16 @@ def __init_finalize__(self, **kwargs):
         language = kwargs.pop('language', configuration['language'])
         platform = kwargs.pop('platform', configuration['platform'])
 
-        if isinstance(platform, NvidiaDevice):
-            self.cflags.remove('-std=c99')
+        if platform is NVIDIAX:
+            self.cflags.remove(f'-std={self.std}')
             # Add flags for OpenMP offloading
             if language in ['C', 'openmp']:
                 cc = get_nvidia_cc()
                 if cc:
                     self.cflags += ['-Xopenmp-target', f'-march=sm_{cc}']
                 self.ldflags += ['-fopenmp', '-fopenmp-targets=nvptx64-nvidia-cuda']
         elif platform is AMDGPUX:
-            self.cflags.remove('-std=c99')
+            self.cflags.remove(f'-std={self.std}')
             # Add flags for OpenMP offloading
             if language in ['C', 'openmp']:
                 self.ldflags += ['-target', 'x86_64-pc-linux-gnu']
@@ -558,9 +563,9 @@ def __init_finalize__(self, **kwargs):
             self.ldflags += ['-fopenmp']
 
         if isinstance(platform, NvidiaDevice):
-            self.cflags.remove('-std=c99')
+            self.cflags.remove(f'-std={self.std}')
         elif platform is AMDGPUX:
-            self.cflags.remove('-std=c99')
+            self.cflags.remove(f'-std={self.std}')
             # Add flags for OpenMP offloading
             if language in ['C', 'openmp']:
                 self.ldflags += ['-target', 'x86_64-pc-linux-gnu']
@@ -595,15 +600,15 @@ def __lookup_cmds__(self):
 
 class PGICompiler(Compiler):
 
-    _cpp = True
+    default_cpp = True
 
     def __init_finalize__(self, **kwargs):
 
-        self.cflags.remove('-std=c99')
+        self.cflags.remove(f'-std={self.std}')
         self.cflags.remove('-O3')
         self.cflags.remove('-Wall')
 
-        self.cflags.append('-std=c++14')
+        self.cflags.append(f'-std={self.std}')
 
         language = kwargs.pop('language', configuration['language'])
         platform = kwargs.pop('platform', configuration['platform'])
@@ -648,14 +653,14 @@ def __lookup_cmds__(self):
 
 class CudaCompiler(Compiler):
 
-    _cpp = True
+    default_cpp = True
 
     def __init_finalize__(self, **kwargs):
 
-        self.cflags.remove('-std=c99')
+        self.cflags.remove(f'-std={self.std}')
         self.cflags.remove('-Wall')
         self.cflags.remove('-fPIC')
-        self.cflags.extend(['-std=c++14', '-Xcompiler', '-fPIC'])
+        self.cflags.extend([f'-std={self.std}', '-Xcompiler', '-fPIC'])
 
         if configuration['mpi']:
             # We rather use `nvcc` to compile MPI, but for this we have to
@@ -722,14 +727,14 @@ def __lookup_cmds__(self):
 
 class HipCompiler(Compiler):
 
-    _cpp = True
+    default_cpp = True
 
     def __init_finalize__(self, **kwargs):
 
-        self.cflags.remove('-std=c99')
+        self.cflags.remove(f'-std={self.std}')
         self.cflags.remove('-Wall')
         self.cflags.remove('-fPIC')
-        self.cflags.extend(['-std=c++14', '-fPIC'])
+        self.cflags.extend([f'-std={self.std}', '-fPIC'])
 
         if configuration['mpi']:
             # We rather use `hipcc` to compile MPI, but for this we have to
@@ -883,7 +888,7 @@ def __lookup_cmds__(self):
 
 class SyclCompiler(OneapiCompiler):
 
-    _cpp = True
+    default_cpp = True
 
     def __init_finalize__(self, **kwargs):
         IntelCompiler.__init_finalize__(self, **kwargs)
@@ -894,7 +899,7 @@ def __init_finalize__(self, **kwargs):
         if language != 'sycl':
             warning("Expected language sycl with SyclCompiler")
 
-        self.cflags.remove('-std=c99')
+        self.cflags.remove(f'-std={self.std}')
         self.cflags.append('-fsycl')
 
         self.cflags.remove('-g')  # -g disables some optimizations in IGC
@@ -950,7 +955,7 @@ def __new__(cls, *args, **kwargs):
         obj = super().__new__(cls)
         # Keep base to initialize accordingly
         obj._base = kwargs.pop('base', _base)
-        obj._cpp = obj._base._cpp
+        obj.default_cpp = obj._base.default_cpp
 
         return obj
 

devito/core/__init__.py

@@ -2,11 +2,19 @@
 from devito.core.cpu import (Cpu64NoopCOperator, Cpu64NoopOmpOperator,
                              Cpu64AdvCOperator, Cpu64AdvOmpOperator,
                              Cpu64FsgCOperator, Cpu64FsgOmpOperator,
-                             Cpu64CustomOperator)
+                             Cpu64CustomOperator, Cpu64CXXCustomOperator,
+                             Cpu64CXXNoopCOperator, Cpu64CXXNoopOmpOperator,
+                             Cpu64AdvCXXOperator, Cpu64CXXAdvOmpOperator,
+                             Cpu64CXXFsgCOperator, Cpu64CXXFsgOmpOperator)
+
 from devito.core.intel import (Intel64AdvCOperator, Intel64AdvOmpOperator,
-                               Intel64FsgCOperator, Intel64FsgOmpOperator)
-from devito.core.arm import ArmAdvCOperator, ArmAdvOmpOperator
-from devito.core.power import PowerAdvCOperator, PowerAdvOmpOperator
+                               Intel64FsgCOperator, Intel64FsgOmpOperator,
+                               Intel64CXXAdvCOperator, Intel64CXXAdvOmpOperator,
+                               Intel64CXXFsgCOperator, Intel64CXXFsgOmpOperator)
+from devito.core.arm import (ArmAdvCOperator, ArmAdvOmpOperator,
+                             ArmCXXAdvCOperator, ArmCXXAdvOmpOperator)
+from devito.core.power import (PowerAdvCOperator, PowerAdvOmpOperator,
+                               PowerCXXAdvCOperator, PowerCXXAdvOmpOperator)
 from devito.core.gpu import (DeviceNoopOmpOperator, DeviceNoopAccOperator,
                              DeviceAdvOmpOperator, DeviceAdvAccOperator,
                              DeviceFsgOmpOperator, DeviceFsgAccOperator,
@@ -16,26 +24,43 @@
 # Register CPU Operators
 operator_registry.add(Cpu64CustomOperator, Cpu64, 'custom', 'C')
 operator_registry.add(Cpu64CustomOperator, Cpu64, 'custom', 'openmp')
+operator_registry.add(Cpu64CXXCustomOperator, Cpu64, 'custom', 'CXX')
+operator_registry.add(Cpu64CXXCustomOperator, Cpu64, 'custom', 'CXXopenmp')
 
 operator_registry.add(Cpu64NoopCOperator, Cpu64, 'noop', 'C')
 operator_registry.add(Cpu64NoopOmpOperator, Cpu64, 'noop', 'openmp')
+operator_registry.add(Cpu64CXXNoopCOperator, Cpu64, 'noop', 'CXX')
+operator_registry.add(Cpu64CXXNoopOmpOperator, Cpu64, 'noop', 'CXXopenmp')
 
 operator_registry.add(Cpu64AdvCOperator, Cpu64, 'advanced', 'C')
 operator_registry.add(Cpu64AdvOmpOperator, Cpu64, 'advanced', 'openmp')
+operator_registry.add(Cpu64AdvCXXOperator, Cpu64, 'advanced', 'CXX')
+operator_registry.add(Cpu64CXXAdvOmpOperator, Cpu64, 'advanced', 'CXXopenmp')
 
 operator_registry.add(Cpu64FsgCOperator, Cpu64, 'advanced-fsg', 'C')
 operator_registry.add(Cpu64FsgOmpOperator, Cpu64, 'advanced-fsg', 'openmp')
+operator_registry.add(Cpu64CXXFsgCOperator, Cpu64, 'advanced-fsg', 'CXX')
+operator_registry.add(Cpu64CXXFsgOmpOperator, Cpu64, 'advanced-fsg', 'CXXopenmp')
 
 operator_registry.add(Intel64AdvCOperator, Intel64, 'advanced', 'C')
 operator_registry.add(Intel64AdvOmpOperator, Intel64, 'advanced', 'openmp')
+operator_registry.add(Intel64CXXAdvCOperator, Intel64, 'advanced', 'CXX')
+operator_registry.add(Intel64CXXAdvOmpOperator, Intel64, 'advanced', 'CXXopenmp')
+
 operator_registry.add(Intel64FsgCOperator, Intel64, 'advanced-fsg', 'C')
 operator_registry.add(Intel64FsgOmpOperator, Intel64, 'advanced-fsg', 'openmp')
+operator_registry.add(Intel64CXXFsgCOperator, Intel64, 'advanced-fsg', 'CXX')
+operator_registry.add(Intel64CXXFsgOmpOperator, Intel64, 'advanced-fsg', 'CXXopenmp')
 
 operator_registry.add(ArmAdvCOperator, Arm, 'advanced', 'C')
 operator_registry.add(ArmAdvOmpOperator, Arm, 'advanced', 'openmp')
+operator_registry.add(ArmCXXAdvCOperator, Arm, 'advanced', 'CXX')
+operator_registry.add(ArmCXXAdvOmpOperator, Arm, 'advanced', 'CXXopenmp')
 
 operator_registry.add(PowerAdvCOperator, Power, 'advanced', 'C')
 operator_registry.add(PowerAdvOmpOperator, Power, 'advanced', 'openmp')
+operator_registry.add(PowerCXXAdvCOperator, Power, 'advanced', 'CXX')
+operator_registry.add(PowerCXXAdvOmpOperator, Power, 'advanced', 'CXXopenmp')
 
 # Register Device Operators
 operator_registry.add(DeviceCustomOmpOperator, Device, 'custom', 'C')

devito/core/arm.py

@@ -1,19 +1,24 @@
-from devito.core.cpu import Cpu64AdvOperator
-from devito.passes.iet import CTarget, OmpTarget
+from devito.core.cpu import (Cpu64AdvOperator, Cpu64AdvCXXOperator,
+                             Cpu64AdvCOperator)
+from devito.passes.iet import OmpTarget, CXXOmpTarget
 
-__all__ = ['ArmAdvCOperator', 'ArmAdvOmpOperator']
+__all__ = ['ArmAdvCOperator', 'ArmAdvOmpOperator', 'ArmCXXAdvCOperator',
+           'ArmCXXAdvOmpOperator']
 
 
-class ArmAdvOperator(Cpu64AdvOperator):
-    pass
+ArmAdvOperator = Cpu64AdvOperator
+ArmAdvCOperator = Cpu64AdvCOperator
+ArmCXXAdvOperator = Cpu64AdvCXXOperator
+ArmCXXAdvCOperator = Cpu64AdvCXXOperator
 
 
-class ArmAdvCOperator(ArmAdvOperator):
-    _Target = CTarget
-
-
-class ArmAdvOmpOperator(ArmAdvOperator):
+class ArmAdvOmpOperator(ArmAdvCOperator):
     _Target = OmpTarget
 
     # Avoid nested parallelism on ThunderX2
     PAR_NESTED = 4
+
+
+class ArmCXXAdvOmpOperator(ArmAdvOmpOperator):
+    _Target = CXXOmpTarget
+    LINEARIZE = True

devito/core/cpu.py

@@ -78,7 +78,7 @@ def _normalize_kwargs(cls, **kwargs):
 
         # Misc
         o['opt-comms'] = oo.pop('opt-comms', True)
-        o['linearize'] = oo.pop('linearize', False)
+        o['linearize'] = oo.pop('linearize', cls.LINEARIZE)
         o['mapify-reduce'] = oo.pop('mapify-reduce', cls.MAPIFY_REDUCE)
         o['index-mode'] = oo.pop('index-mode', cls.INDEX_MODE)
         o['place-transfers'] = oo.pop('place-transfers', True)
@@ -318,28 +318,63 @@ def _make_iet_passes_mapper(cls, **kwargs):
     assert not (set(_known_passes) & set(_known_passes_disabled))
 
 
+class Cpu64CXXCustomOperator(Cpu64CustomOperator):
+
+    _Target = CXXTarget
+    LINEARIZE = True
+
 # Language level
 
 
 class Cpu64NoopCOperator(Cpu64NoopOperator):
     _Target = CTarget
 
 
+class Cpu64CXXNoopCOperator(Cpu64NoopOperator):
+    _Target = CXXTarget
+    LINEARIZE = True
+
+
 class Cpu64NoopOmpOperator(Cpu64NoopOperator):
     _Target = COmpTarget
 
 
+class Cpu64CXXNoopOmpOperator(Cpu64NoopOperator):
+    _Target = CXXOmpTarget
+    LINEARIZE = True
+
+
 class Cpu64AdvCOperator(Cpu64AdvOperator):
     _Target = CTarget
 
 
+class Cpu64AdvCXXOperator(Cpu64AdvOperator):
+    _Target = CXXTarget
+    LINEARIZE = True
+
+
 class Cpu64AdvOmpOperator(Cpu64AdvOperator):
     _Target = COmpTarget
 
 
+class Cpu64CXXAdvOmpOperator(Cpu64AdvOperator):
+    _Target = CXXOmpTarget
+    LINEARIZE = True
+
+
 class Cpu64FsgCOperator(Cpu64FsgOperator):
     _Target = CTarget
 
 
+class Cpu64CXXFsgCOperator(Cpu64FsgOperator):
+    _Target = CXXTarget
+    LINEARIZE = True
+
+
 class Cpu64FsgOmpOperator(Cpu64FsgOperator):
     _Target = COmpTarget
+
+
+class Cpu64CXXFsgOmpOperator(Cpu64FsgOperator):
+    _Target = CXXOmpTarget
+    LINEARIZE = True

devito/core/intel.py

@@ -1,11 +1,18 @@
 from devito.core.cpu import (Cpu64AdvCOperator, Cpu64AdvOmpOperator,
-                             Cpu64FsgCOperator, Cpu64FsgOmpOperator)
+                             Cpu64FsgCOperator, Cpu64FsgOmpOperator,
+                             Cpu64AdvCXXOperator, Cpu64CXXAdvOmpOperator,
+                             Cpu64CXXFsgCOperator, Cpu64CXXFsgOmpOperator)
 
 __all__ = ['Intel64AdvCOperator', 'Intel64AdvOmpOperator', 'Intel64FsgCOperator',
-           'Intel64FsgOmpOperator']
+           'Intel64FsgOmpOperator', 'Intel64CXXAdvCOperator', 'Intel64CXXAdvOmpOperator',
+           'Intel64CXXFsgCOperator', 'Intel64CXXFsgOmpOperator']
 
 
 Intel64AdvCOperator = Cpu64AdvCOperator
 Intel64AdvOmpOperator = Cpu64AdvOmpOperator
 Intel64FsgCOperator = Cpu64FsgCOperator
 Intel64FsgOmpOperator = Cpu64FsgOmpOperator
+Intel64CXXAdvCOperator = Cpu64AdvCXXOperator
+Intel64CXXAdvOmpOperator = Cpu64CXXAdvOmpOperator
+Intel64CXXFsgCOperator = Cpu64CXXFsgCOperator
+Intel64CXXFsgOmpOperator = Cpu64CXXFsgOmpOperator

devito/core/operator.py

@@ -143,6 +143,11 @@ class BasicOperator(Operator):
     The target language constructor, to be specified by subclasses.
     """
 
+    LINEARIZE = False
+    """
+    Linearize n-dimensional Indexeds.
+    """
+
     @classmethod
     def _normalize_kwargs(cls, **kwargs):
         # Will be populated with dummy values; this method is actually overriden

devito/core/power.py

@@ -1,6 +1,10 @@
-from devito.core.cpu import Cpu64AdvCOperator, Cpu64AdvOmpOperator
+from devito.core.cpu import (Cpu64AdvCOperator, Cpu64AdvOmpOperator,
+                             Cpu64AdvCXXOperator, Cpu64CXXAdvOmpOperator)
 
-__all__ = ['PowerAdvCOperator', 'PowerAdvOmpOperator']
+__all__ = ['PowerAdvCOperator', 'PowerAdvOmpOperator',
+           'PowerCXXAdvCOperator', 'PowerCXXAdvOmpOperator']
 
 PowerAdvCOperator = Cpu64AdvCOperator
 PowerAdvOmpOperator = Cpu64AdvOmpOperator
+PowerCXXAdvCOperator = Cpu64AdvCXXOperator
+PowerCXXAdvOmpOperator = Cpu64CXXAdvOmpOperator

devito/ir/__init__.py

@@ -2,4 +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
+from devito.ir.cgen import *  # noqa