compiler: Remove macro generation and start work on CXX

Author: EdCaunt

devito/finite_differences/differentiable.py

@@ -658,7 +658,7 @@ def __new__(cls, *args, **kwargs):
 
         if not np.issubdtype(new_args[0].dtype, np.complexfloating):
             raise ValueError(f"{cls.__name__} requires a complex dtype,"
-                             f" not {new_args[0].dtype}.")
+                             f" not {new_args[0].dtype.__name__}.")
 
         return super().__new__(cls, *new_args, **kwargs)
 

devito/ir/cgen/printer.py

@@ -217,14 +217,6 @@ def _print_SafeInv(self, expr):
         val = self._print(expr.val)
         return f'SAFEINV({val}, {base})'
 
-    def _print_Re(self, expr):
-        """Print an Re as an access into the second entry of a float array."""
-        return f"Re({self._print(expr.args[0])})"
-
-    def _print_Im(self, expr):
-        """Print an Im as an access into the second entry of a float array."""
-        return f"Im({self._print(expr.args[0])})"
-
     def _print_Mod(self, expr):
         """Print a Mod as a C-like %-based operation."""
         args = [f'({self._print(a)})' for a in expr.args]

devito/passes/iet/languages/C.py

@@ -55,3 +55,13 @@ class CPrinter(BasePrinter, C99CodePrinter):
 
     def _print_ImaginaryUnit(self, expr):
         return '_Complex_I'
+
+    def _print_Re(self, expr):
+        """Print an Re as an access into the second entry of a float array."""
+        return (f'{self.func_prefix(expr)}real{self.func_literal(expr).lower()}'
+                f'({self._print(expr.args[0])})')
+
+    def _print_Im(self, expr):
+        """Print an Im as an access into the second entry of a float array."""
+        return (f'{self.func_prefix(expr)}imag{self.func_literal(expr).lower()}'
+                f'({self._print(expr.args[0])})')

devito/passes/iet/languages/CXX.py

@@ -103,6 +103,13 @@ class CXXPrinter(BasePrinter, CXX11CodePrinter):
 
     def _print_ImaginaryUnit(self, expr):
         return f'1i{self.prec_literal(expr).lower()}'
+        # return '1i'
+
+    def _print_Re(self, expr):
+        return f'{self._ns}real({self._print(expr.args[0])})'
+
+    def _print_Im(self, expr):
+        return f'{self._ns}imag({self._print(expr.args[0])})'
 
     def _print_Cast(self, expr):
         # The CXX recommended way to cast is to use static_cast

devito/passes/iet/misc.py

@@ -5,7 +5,7 @@
 import sympy
 
 from devito.finite_differences import Max, Min
-from devito.finite_differences.differentiable import SafeInv, Re, Im
+from devito.finite_differences.differentiable import SafeInv
 from devito.logger import warning
 from devito.ir import (Any, Forward, DummyExpr, Iteration, List, Prodder,
                        FindApplications, FindNodes, FindSymbols, Transformer,
@@ -245,22 +245,6 @@ def _(expr, langbb):
              f'(((a) < {eps}F || ({b}) < {eps}F) ? (0.0F) : ((1.0F) / (a)))'),), {}
 
 
-@_lower_macro_math.register(Re)
-def _(expr, langbb):
-    return (('Re(x)',
-             '(_Generic((x), '
-             'float _Complex : (float *) &(x), '
-             'double _Complex : (double *) &(x))[0])'),), {}
-
-
-@_lower_macro_math.register(Im)
-def _(expr, langbb):
-    return (('Im(x)',
-             '(_Generic((x), '
-             'float _Complex : (float *) &(x), '
-             'double _Complex : (double *) &(x))[1])'),), {}
-
-
 @iet_pass
 def minimize_symbols(iet):
     """

tests/test_symbolics.py

@@ -7,7 +7,7 @@
 from sympy import Expr, Symbol
 from devito import (Constant, Dimension, Grid, Function, solve, TimeFunction, Eq,  # noqa
                     Operator, SubDimension, norm, Le, Ge, Gt, Lt, Abs, sin, cos,
-                    Min, Max, Re, Im)
+                    Min, Max, Re, Im, switchconfig)
 from devito.finite_differences.differentiable import SafeInv, Weights
 from devito.ir import Expression, FindNodes, ccode
 from devito.symbolics import (retrieve_functions, retrieve_indexed, evalrel,  # noqa
@@ -821,6 +821,7 @@ def test_assumptions(self, op, expr, assumptions, expected):
 
 
 class TestComplexParts:
+    # TODO: Add a cxx switchconfig
     def setup_basic(self, dtype):
         grid = Grid(shape=(5,), extent=(4.,))
         f = Function(name='f', grid=grid, dtype=dtype)
@@ -830,73 +831,87 @@ def setup_basic(self, dtype):
         f_imag = Function(name='f_imag', grid=grid)
         return f, f_real, f_imag
 
-    def test_printing(self):
+    def run_operator(self, eqs, cxx):
+        if cxx:
+            with switchconfig(language='CXX'):
+                Operator(eqs)()
+        else:
+            Operator(eqs)()
+
+    @pytest.mark.parametrize('cxx', [False, True])
+    def test_printing(self, cxx):
         f, f_real, f_imag = self.setup_basic(np.complex64)
 
         eq_re = Eq(f_real, Re(f))
         eq_im = Eq(f_imag, Im(f))
 
-        op = Operator([eq_re, eq_im])
-
-        assert ("#define Im(x) (_Generic((x), float _Complex : (float *) &(x), "
-                "double _Complex : (double *) &(x))[1])") in str(op.ccode)
-        assert ("#define Re(x) (_Generic((x), float _Complex : (float *) &(x), "
-                "double _Complex : (double *) &(x))[0])") in str(op.ccode)
+        if cxx:
+            with switchconfig(language='CXX'):
+                op = Operator([eq_re, eq_im])
+                assert "f_real[x + 1] = std::real(f[x + 1])" in str(op.ccode)
+                assert "f_imag[x + 1] = std::imag(f[x + 1])" in str(op.ccode)
 
-        assert "f_real[x + 1] = Re(f[x + 1])" in str(op.ccode)
-        assert "f_imag[x + 1] = Im(f[x + 1])" in str(op.ccode)
+        else:
+            op = Operator([eq_re, eq_im])
+            assert "f_real[x + 1] = crealf(f[x + 1])" in str(op.ccode)
+            assert "f_imag[x + 1] = cimagf(f[x + 1])" in str(op.ccode)
 
+    @pytest.mark.parametrize('cxx', [False, True])
     @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
-    def test_trivial(self, dtype):
+    def test_trivial(self, cxx, dtype):
         f, f_real, f_imag = self.setup_basic(dtype)
 
-        eq_re = Eq(f_real, Re(f+1))
-        eq_im = Eq(f_imag, Im(f+1))
+        eq_re = Eq(f_real, Re(f+1.))
+        eq_im = Eq(f_imag, Im(f+1.))
 
-        Operator([eq_re, eq_im])()
+        self.run_operator([eq_re, eq_im], cxx)
 
         rcheck = np.array([2., 3., 4., 5., 6.])
         icheck = np.array([12., 11., 10., 9., 8.])
         assert np.all(np.isclose(f_real.data, rcheck))
         assert np.all(np.isclose(f_imag.data, icheck))
 
+    @pytest.mark.parametrize('cxx', [False, True])
     @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
-    def test_trivial_imag(self, dtype):
+    def test_trivial_imag(self, cxx, dtype):
         f, f_real, f_imag = self.setup_basic(dtype)
 
         eq_re = Eq(f_real, Re(f+1j))
         eq_im = Eq(f_imag, Im(f+1j))
 
-        Operator([eq_re, eq_im])()
+        self.run_operator([eq_re, eq_im], cxx)
 
         rcheck = np.array([1., 2., 3., 4., 5.])
         icheck = np.array([13., 12., 11., 10., 9.])
         assert np.all(np.isclose(f_real.data, rcheck))
         assert np.all(np.isclose(f_imag.data, icheck))
 
-    def test_deriv(self):
+    @pytest.mark.parametrize('cxx', [False, True])
+    def test_deriv(self, cxx):
         f, f_real, f_imag = self.setup_basic(np.complex64)
 
         eq_re = Eq(f_real, Re(f.dx))
         eq_im = Eq(f_imag, Im(f.dx))
 
-        Operator([eq_re, eq_im])()
+        self.run_operator([eq_re, eq_im], cxx)
 
         assert np.all(np.isclose(f_real.data, 1.))
         assert np.all(np.isclose(f_imag.data, -1.))
 
-    def test_outer_deriv(self):
+    @pytest.mark.parametrize('cxx', [False, True])
+    def test_outer_deriv(self, cxx):
         f, f_real, f_imag = self.setup_basic(np.complex64)
 
         eq_re = Eq(f_real, Re(f).dx)
         eq_im = Eq(f_imag, Im(f).dx)
 
-        Operator([eq_re, eq_im])()
+        self.run_operator([eq_re, eq_im], cxx)
 
         assert np.all(np.isclose(f_real.data, 1.))
         assert np.all(np.isclose(f_imag.data, -1.))
 
-    def test_mul(self):
+    @pytest.mark.parametrize('cxx', [False, True])
+    def test_mul(self, cxx):
         grid = Grid(shape=(5,))
 
         f = Function(name='f', grid=grid, dtype=np.complex64)
@@ -916,7 +931,7 @@ def test_mul(self):
         eq_fh_re = Eq(fh_re, Re(f*h))
         eq_fh_im = Eq(fh_im, Im(f*h))
 
-        Operator([eq_fg_re, eq_fg_im, eq_fh_re, eq_fh_im])()
+        self.run_operator([eq_fg_re, eq_fg_im, eq_fh_re, eq_fh_im], cxx)
 
         assert np.all(np.isclose(fg_re.data, 2.))
         assert np.all(np.isclose(fg_im.data, 2.))