api: Introduce complex numbers support (np.complex64/128)

devito/__init__.py

@@ -56,7 +56,8 @@ def reinit_compiler(val):
     """
     Re-initialize the Compiler.
     """
-    configuration['compiler'].__init__(suffix=configuration['compiler'].suffix,
+    configuration['compiler'].__init__(name=configuration['compiler'].name,
+                                       suffix=configuration['compiler'].suffix,
                                        mpi=configuration['mpi'])
     return val
 
@@ -65,7 +66,7 @@ def reinit_compiler(val):
 configuration.add('platform', 'cpu64', list(platform_registry),
                   callback=lambda i: platform_registry[i]())
 configuration.add('compiler', 'custom', compiler_registry,
-                  callback=lambda i: compiler_registry[i]())
+                  callback=lambda i: compiler_registry[i](name=i))
 
 # Setup language for shared-memory parallelism
 preprocessor = lambda i: {0: 'C', 1: 'openmp'}.get(i, i)  # Handles DEVITO_OPENMP deprec

devito/arch/compiler.py

@@ -180,12 +180,20 @@ def __init__(self):
     """
 
     fields = {'cc', 'ld'}
-    _cpp = False
+    default_cpp = False
+    _cxxstd = 'c++14'
+    _cstd = 'c99'
 
     def __init__(self, **kwargs):
+        name = kwargs.pop('name', self.__class__.__name__)
+        if isinstance(name, Compiler):
+            name = name.name
+        self._name = name
+
         super().__init__(**kwargs)
 
         self.__lookup_cmds__()
+        self._cpp = kwargs.get('cpp', self.default_cpp)
 
         self.suffix = kwargs.get('suffix')
         if not kwargs.get('mpi'):
@@ -196,7 +204,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 = []
@@ -226,13 +234,13 @@ def __new_with__(self, **kwargs):
         Create a new Compiler from an existing one, inherenting from it
         the flags that are not specified via ``kwargs``.
         """
-        return self.__class__(suffix=kwargs.pop('suffix', self.suffix),
+        return self.__class__(name=self.name, suffix=kwargs.pop('suffix', self.suffix),
                               mpi=kwargs.pop('mpi', configuration['mpi']),
                               **kwargs)
 
     @property
     def name(self):
-        return self.__class__.__name__
+        return self._name
 
     @property
     def version(self):
@@ -248,6 +256,10 @@ def version(self):
 
         return version
 
+    @property
+    def std(self):
+        return self._cxxstd if self._cpp else self._cstd
+
     def get_version(self):
         result, stdout, stderr = call_capture_output((self.cc, "--version"))
         if result != 0:
@@ -488,15 +500,15 @@ def __init_finalize__(self, **kwargs):
         platform = kwargs.pop('platform', configuration['platform'])
 
         if isinstance(platform, NvidiaDevice):
-            self.cflags.remove('-std=c99')
+            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', '-march=sm_%s' % 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']
@@ -556,9 +568,9 @@ def __init_finalize__(self, **kwargs):
             self.cflags.append('-ffast-math')
 
         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']
@@ -594,15 +606,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++11')
+        self.cflags.append(f'-std={self.std}')
 
         language = kwargs.pop('language', configuration['language'])
         platform = kwargs.pop('platform', configuration['platform'])
@@ -645,14 +657,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
@@ -719,14 +731,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
@@ -833,7 +845,7 @@ def __init_finalize__(self, **kwargs):
         language = kwargs.pop('language', configuration['language'])
 
         if language == 'sycl':
-            raise ValueError("Use SyclCompiler to jit-compile sycl")
+            warning("Use SyclCompiler to jit-compile sycl")
 
         elif language == 'openmp':
             # Earlier versions to OneAPI 2023.2.0 (clang17 underneath), have an
@@ -880,7 +892,7 @@ def __lookup_cmds__(self):
 
 class SyclCompiler(OneapiCompiler):
 
-    _cpp = True
+    default_cpp = True
 
     def __init_finalize__(self, **kwargs):
         IntelCompiler.__init_finalize__(self, **kwargs)
@@ -889,9 +901,9 @@ def __init_finalize__(self, **kwargs):
         language = kwargs.pop('language', configuration['language'])
 
         if language != 'sycl':
-            raise ValueError("Expected language sycl with SyclCompiler")
+            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
@@ -947,7 +959,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
 
@@ -986,15 +998,19 @@ class CompilerRegistry(dict):
     """
 
     def __getitem__(self, key):
+        if isinstance(key, Compiler):
+            key = key.name
+
         if key.startswith('gcc-'):
             i = key.split('-')[1]
             return partial(GNUCompiler, suffix=i)
+
         return super().__getitem__(key)
 
-    def __contains__(self, k):
-        if isinstance(k, Compiler):
-            k = k.name
-        return k in self.keys() or k.startswith('gcc-')
+    def __contains__(self, key):
+        if isinstance(key, Compiler):
+            key = key.name
+        return key in self.keys() or key.startswith('gcc-')
 
 
 _compiler_registry = {
@@ -1013,6 +1029,7 @@ def __contains__(self, k):
     'nvc++': NvidiaCompiler,
     'nvidia': NvidiaCompiler,
     'cuda': CudaCompiler,
+    'nvcc': CudaCompiler,
     'osx': ClangCompiler,
     'intel': OneapiCompiler,
     'icx': OneapiCompiler,

devito/core/__init__.py

@@ -2,11 +2,19 @@
 from devito.core.cpu import (Cpu64NoopCOperator, Cpu64NoopOmpOperator,
                              Cpu64AdvCOperator, Cpu64AdvOmpOperator,
                              Cpu64FsgCOperator, Cpu64FsgOmpOperator,
-                             Cpu64CustomOperator)
+                             Cpu64CustomOperator, Cpu64CustomCXXOperator,
+                             Cpu64CXXNoopCOperator, Cpu64CXXNoopOmpOperator,
+                             Cpu64AdvCXXOperator, Cpu64AdvCXXOmpOperator,
+                             Cpu64FsgCXXOperator, Cpu64FsgCXXOmpOperator)
+
 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, Intel64AdvCXXOmpOperator,
+                               Intel64FsgCXXOperator, Intel64FsgCXXOmpOperator)
+from devito.core.arm import (ArmAdvCOperator, ArmAdvOmpOperator,
+                             ArmAdvCXXOperator, ArmAdvCXXOmpOperator)
+from devito.core.power import (PowerAdvCOperator, PowerAdvOmpOperator,
+                               PowerCXXAdvCOperator, PowerAdvCXXOmpOperator)
 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(Cpu64CustomCXXOperator, Cpu64, 'custom', 'CXX')
+operator_registry.add(Cpu64CustomCXXOperator, 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(Cpu64AdvCXXOmpOperator, Cpu64, 'advanced', 'CXXopenmp')
 
 operator_registry.add(Cpu64FsgCOperator, Cpu64, 'advanced-fsg', 'C')
 operator_registry.add(Cpu64FsgOmpOperator, Cpu64, 'advanced-fsg', 'openmp')
+operator_registry.add(Cpu64FsgCXXOperator, Cpu64, 'advanced-fsg', 'CXX')
+operator_registry.add(Cpu64FsgCXXOmpOperator, 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(Intel64AdvCXXOmpOperator, Intel64, 'advanced', 'CXXopenmp')
+
 operator_registry.add(Intel64FsgCOperator, Intel64, 'advanced-fsg', 'C')
 operator_registry.add(Intel64FsgOmpOperator, Intel64, 'advanced-fsg', 'openmp')
+operator_registry.add(Intel64FsgCXXOperator, Intel64, 'advanced-fsg', 'CXX')
+operator_registry.add(Intel64FsgCXXOmpOperator, Intel64, 'advanced-fsg', 'CXXopenmp')
 
 operator_registry.add(ArmAdvCOperator, Arm, 'advanced', 'C')
 operator_registry.add(ArmAdvOmpOperator, Arm, 'advanced', 'openmp')
+operator_registry.add(ArmAdvCXXOperator, Arm, 'advanced', 'CXX')
+operator_registry.add(ArmAdvCXXOmpOperator, 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(PowerAdvCXXOmpOperator, Power, 'advanced', 'CXXopenmp')
 
 # Register Device Operators
 operator_registry.add(DeviceCustomOmpOperator, Device, 'custom', 'C')

devito/core/arm.py

@@ -1,19 +1,23 @@
-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', 'ArmAdvCXXOperator',
+           'ArmAdvCXXOmpOperator']
 
 
-class ArmAdvOperator(Cpu64AdvOperator):
-    pass
+ArmAdvOperator = Cpu64AdvOperator
+ArmAdvCOperator = Cpu64AdvCOperator
+ArmAdvCXXOperator = Cpu64AdvCXXOperator
 
 
-class ArmAdvCOperator(ArmAdvOperator):
-    _Target = CTarget
-
-
-class ArmAdvOmpOperator(ArmAdvOperator):
+class ArmAdvOmpOperator(ArmAdvCOperator):
     _Target = OmpTarget
 
     # Avoid nested parallelism on ThunderX2
     PAR_NESTED = 4
+
+
+class ArmAdvCXXOmpOperator(ArmAdvOmpOperator):
+    _Target = CXXOmpTarget
+    LINEARIZE = True