compiler: rename lang option to langbb for clarity

Author: mloubout

devito/arch/compiler.py

@@ -185,10 +185,11 @@ def __init__(self):
     _cstd = 'c99'
 
     def __init__(self, **kwargs):
-        name = kwargs.pop('name', self.__class__.__name__)
-        if isinstance(name, Compiler):
-            name = name.name
-        self._name = name
+        maybe_name = kwargs.pop('name', self.__class__.__name__)
+        if isinstance(maybe_name, Compiler):
+            self._name = maybe_name.name
+        else:
+            self._name = maybe_name
 
         super().__init__(**kwargs)
 
@@ -658,7 +659,7 @@ def __init_finalize__(self, **kwargs):
 
         self.cflags.remove('-Wall')
         self.cflags.remove('-fPIC')
-        self.cflags.append('-Xcompiler')
+        self.cflags.extend(['-Xcompiler', '-fPIC'])
 
         if configuration['mpi']:
             # We rather use `nvcc` to compile MPI, but for this we have to

devito/ir/iet/utils.py

@@ -1,3 +1,5 @@
+import numpy as np
+
 from devito.ir.iet import FindSections, FindSymbols
 from devito.symbolics import Keyword, Macro
 from devito.tools import filter_ordered
@@ -166,3 +168,20 @@ def maybe_alias(obj, candidate):
         # the __rkwargs__ except for e.g. the name
 
     return False
+
+
+def has_dtype(iet, dtype):
+    """
+    Check if the given IET has at least one symbol with the given dtype or
+    dtype kind.
+    """
+    for f in FindSymbols().visit(iet):
+        try:
+            # Check if the dtype matches exactly (dtype input)
+            # or matches the generic kind (dtype generic input)
+            if np.issubdtype(f.dtype, dtype) or f.dtype == dtype:
+                return True
+        except TypeError:
+            continue
+    else:
+        return False

devito/operator/operator.py

@@ -261,7 +261,7 @@ def _lower(cls, expressions, **kwargs):
         # Create a symbol registry
         kwargs.setdefault('sregistry', SymbolRegistry())
         # Add lang-base kwargs
-        kwargs.setdefault('lang', cls._Target.lang())
+        kwargs.setdefault('langbb', cls._Target.lang())
         kwargs.setdefault('printer', cls._Target.Printer)
 
         expressions = as_tuple(expressions)

devito/passes/clusters/cse.py

@@ -70,7 +70,10 @@ def cse(cluster, sregistry=None, options=None, **kwargs):
     """
     min_cost = options['cse-min-cost']
     mode = options['cse-algo']
-    dtype = np.promote_types(options['scalar-min-type'], cluster.dtype).type
+    try:
+        dtype = np.promote_types(options['scalar-min-type'], cluster.dtype).type
+    except TypeError:
+        dtype = cluster.dtype
 
     if cluster.is_fence:
         return cluster

devito/passes/iet/dtypes.py

@@ -1,7 +1,8 @@
 import numpy as np
 
 from devito.arch.compiler import Compiler
-from devito.ir import Callable, FindSymbols, SymbolRegistry
+from devito.ir import Callable, SymbolRegistry
+from devito.ir.iet.utils import has_dtype
 from devito.passes.iet.engine import iet_pass
 from devito.passes.iet.langbase import LangBB
 from devito.tools import as_tuple
@@ -10,33 +11,27 @@
 
 
 @iet_pass
-def _complex_includes(iet: Callable, lang: type[LangBB], compiler: Compiler,
+def _complex_includes(iet: Callable, langbb: type[LangBB], compiler: Compiler,
                       sregistry: SymbolRegistry) -> tuple[Callable, dict]:
     """
     Includes complex arithmetic headers for the given language, if needed.
     """
     # Check if there are complex numbers that always take dtype precedence
-    for f in FindSymbols().visit(iet):
-        try:
-            if np.issubdtype(f.dtype, np.complexfloating):
-                break
-        except TypeError:
-            continue
-    else:
+    if not has_dtype(iet, np.complexfloating):
         return iet, {}
 
     metadata = {}
-    lib = as_tuple(lang['includes-complex'])
+    lib = as_tuple(langbb['includes-complex'])
 
-    if lang.get('complex-namespace') is not None:
-        metadata['namespaces'] = lang['complex-namespace']
+    if langbb.get('complex-namespace') is not None:
+        metadata['namespaces'] = langbb['complex-namespace']
 
     # Some languges such as c++11 need some extra arithmetic definitions
-    if lang.get('def-complex'):
+    if langbb.get('def-complex'):
         dest = compiler.get_jit_dir()
         hfile = dest.joinpath('complex_arith.h')
         with open(str(hfile), 'w') as ff:
-            ff.write(str(lang['def-complex']))
+            ff.write(str(langbb['def-complex']))
         lib += (str(hfile),)
 
     metadata['includes'] = lib
@@ -47,12 +42,14 @@ def _complex_includes(iet: Callable, lang: type[LangBB], compiler: Compiler,
 dtype_passes = [_complex_includes]
 
 
-def lower_dtypes(graph: Callable, lang: type[LangBB] = None, compiler: Compiler = None,
+def lower_dtypes(graph: Callable,
+                 langbb: type[LangBB] = None,
+                 compiler: Compiler = None,
                  sregistry: SymbolRegistry = None, **kwargs) -> tuple[Callable, dict]:
     """
     Lowers float16 scalar types to pointers since we can't directly pass their
     value. Also includes headers for complex arithmetic if needed.
     """
 
     for dtype_pass in dtype_passes:
-        dtype_pass(graph, lang=lang, compiler=compiler, sregistry=sregistry)
+        dtype_pass(graph, langbb=langbb, compiler=compiler, sregistry=sregistry)

devito/passes/iet/instrument.py

@@ -121,12 +121,12 @@ def instrument_sections(iet, **kwargs):
 
 
 @iet_pass
-def sync_sections(iet, lang=None, profiler=None, **kwargs):
+def sync_sections(iet, langbb=None, profiler=None, **kwargs):
     """
     Wrap sections within global barriers if deemed necessary by the profiler.
     """
     try:
-        sync = lang['map-wait']
+        sync = langbb['map-wait']
     except (KeyError, NotImplementedError):
         return iet, {}
 
@@ -137,7 +137,7 @@ def sync_sections(iet, lang=None, profiler=None, **kwargs):
     for tl in FindNodes(TimedList).visit(iet):
         symbols = FindSymbols().visit(tl)
 
-        queues = [i for i in symbols if isinstance(i, lang.AsyncQueue)]
+        queues = [i for i in symbols if isinstance(i, langbb.AsyncQueue)]
         unnecessary = any(FindNodes(BusyWait).visit(tl))
         if queues and not unnecessary:
             waits = tuple(sync(i) for i in queues)

devito/passes/iet/misc.py

@@ -144,7 +144,7 @@ def generate_macros(graph, **kwargs):
 
 
 @iet_pass
-def _generate_macros(iet, tracker=None, lang=None, **kwargs):
+def _generate_macros(iet, tracker=None, langbb=None, **kwargs):
     # Derive the Macros necessary for the FIndexeds
     iet = _generate_macros_findexeds(iet, tracker=tracker, **kwargs)
 
@@ -155,7 +155,7 @@ def _generate_macros(iet, tracker=None, lang=None, **kwargs):
                      for define, expr in headers)
 
     # Generate Macros from higher-level SymPy objects
-    mheaders, includes = _generate_macros_math(iet, lang=lang)
+    mheaders, includes = _generate_macros_math(iet, langbb=langbb)
     includes = sorted(includes, key=str)
     headers.extend(sorted(mheaders, key=str))
 
@@ -199,42 +199,42 @@ def _generate_macros_findexeds(iet, sregistry=None, tracker=None, **kwargs):
     return iet
 
 
-def _generate_macros_math(iet, lang=None):
+def _generate_macros_math(iet, langbb=None):
     headers = []
     includes = []
     for i in FindApplications().visit(iet):
-        header, include = _lower_macro_math(i, lang)
+        header, include = _lower_macro_math(i, langbb)
         headers.extend(header)
         includes.extend(include)
 
     return headers, set(includes) - {None}
 
 
 @singledispatch
-def _lower_macro_math(expr, lang):
+def _lower_macro_math(expr, langbb):
     return (), {}
 
 
 @_lower_macro_math.register(Min)
 @_lower_macro_math.register(sympy.Min)
-def _(expr, lang):
+def _(expr, langbb):
     if has_integer_args(*expr.args):
         return (('MIN(a,b)', ('(((a) < (b)) ? (a) : (b))')),), {}
     else:
-        return (), as_tuple(lang.get('header-algorithm'))
+        return (), as_tuple(langbb.get('header-algorithm'))
 
 
 @_lower_macro_math.register(Max)
 @_lower_macro_math.register(sympy.Max)
-def _(expr, lang):
+def _(expr, langbb):
     if has_integer_args(*expr.args):
         return (('MAX(a,b)', ('(((a) > (b)) ? (a) : (b))')),), {}
     else:
-        return (), as_tuple(lang.get('header-algorithm'))
+        return (), as_tuple(langbb.get('header-algorithm'))
 
 
 @_lower_macro_math.register(SafeInv)
-def _(expr, lang):
+def _(expr, langbb):
     try:
         eps = np.finfo(expr.base.dtype).resolution**2
     except ValueError:

devito/tools/dtypes_lowering.py

@@ -325,6 +325,16 @@ def is_external_ctype(ctype, includes):
     return False
 
 
+def is_numpy_dtype(dtype):
+    """
+    True if `dtype` is a numpy dtype, False otherwise.
+    """
+    try:
+        return issubclass(dtype, np.generic)
+    except TypeError:
+        return False
+
+
 def infer_dtype(dtypes):
     """
     Given a set of np.dtypes, return the "winning" dtype:
@@ -335,7 +345,9 @@ def infer_dtype(dtypes):
     """
     # Resolve the vector types, if any
     dtypes = {dtypes_vector_mapper.get_base_dtype(i, i) for i in dtypes}
-
+    # Only keep number types
+    dtypes = {i for i in dtypes if is_numpy_dtype(i)}
+    # Separate floating point types from the rest
     fdtypes = {i for i in dtypes if np.issubdtype(i, np.floating) or
                np.issubdtype(i, np.complexfloating)}
     if len(fdtypes) > 1: