compiler: cleanup default includes/header/namespaces

Author: mloubout

devito/arch/archinfo.py

@@ -377,7 +377,7 @@ def cbk(deviceid=0):
         gpu_info = homogenise_gpus(list(gpu_infos.values()))
 
         # Also attach callbacks to retrieve instantaneous memory info
-        # Now this should be done use xpu-smi but for some reason
+        # Now this should be done using xpu-smi but for some reason
         # it throws a lot of weird errors in docker so skipping for now
         for i in ['total', 'free', 'used']:
             def make_cbk(i):

devito/core/__init__.py

@@ -1,24 +1,33 @@
 from devito.arch import Cpu64, Intel64, Arm, Power, Device
-from devito.core.cpu import (Cpu64NoopCOperator, Cpu64NoopOmpOperator,
-                             Cpu64AdvCOperator, Cpu64AdvOmpOperator,
-                             Cpu64FsgCOperator, Cpu64FsgOmpOperator,
-                             Cpu64CustomOperator, Cpu64CustomCXXOperator,
-                             Cpu64CXXNoopCOperator, Cpu64CXXNoopOmpOperator,
-                             Cpu64AdvCXXOperator, Cpu64AdvCXXOmpOperator,
-                             Cpu64FsgCXXOperator, Cpu64FsgCXXOmpOperator)
-
-from devito.core.intel import (Intel64AdvCOperator, Intel64AdvOmpOperator,
-                               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,
-                             DeviceCustomOmpOperator, DeviceCustomAccOperator)
+from devito.core.cpu import (
+    Cpu64NoopCOperator, Cpu64NoopOmpOperator,
+    Cpu64AdvCOperator, Cpu64AdvOmpOperator,
+    Cpu64FsgCOperator, Cpu64FsgOmpOperator,
+    Cpu64CustomOperator, Cpu64CustomCXXOperator,
+    Cpu64CXXNoopCOperator, Cpu64CXXNoopOmpOperator,
+    Cpu64AdvCXXOperator, Cpu64AdvCXXOmpOperator,
+    Cpu64FsgCXXOperator, Cpu64FsgCXXOmpOperator
+)
+from devito.core.intel import (
+    Intel64AdvCOperator, Intel64AdvOmpOperator,
+    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,
+    DeviceCustomOmpOperator, DeviceCustomAccOperator
+)
 from devito.operator.registry import operator_registry
 
 # Register CPU Operators

devito/ir/cgen/printer.py

@@ -49,7 +49,11 @@ class BasePrinter(CodePrinter):
 
     _restrict_keyword = 'restrict'
 
-    _default_includes = []
+    _includes = []
+
+    _namespaces = []
+
+    _headers = [('_POSIX_C_SOURCE', '200809L')]
 
     @property
     def dtype(self):

devito/ir/iet/visitors.py

@@ -649,8 +649,7 @@ def visit_HaloSpot(self, o):
 
     def visit_KernelLaunch(self, o):
         if o.templates:
-            ctemplates = ','.join([str(i) for i in o.templates])
-            templates = f'<{ctemplates}>'
+            templates = f"<{','.join([str(i) for i in o.templates])}>"
         else:
             templates = ''
 
@@ -669,8 +668,29 @@ def visit_KernelLaunch(self, o):
     # Operator-handle machinery
 
     def _operator_includes(self, o):
+        """
+        Generate cgen includes from an iterable of symbols and expressions.
+        """
         return [c.Include(i, system=(False if i.endswith('.h') else True))
-                for i in o._includes]
+                for i in o.includes] + [blankline]
+
+    def _operator_namespaces(self, o):
+        """
+        Generate cgen namespaces from an iterable of symbols and expressions.
+        """
+        namespaces = [self._visit(i) for i in o.namespaces]
+        if namespaces:
+            namespaces.append(blankline)
+        return namespaces
+
+    def _operator_headers(self, o):
+        """
+        Generate cgen headers from an iterable of symbols and expressions.
+        """
+        headers = [c.Define(*as_tuple(i)) for i in o.headers]
+        if headers:
+            headers.append(blankline)
+        return headers
 
     def _operator_typedecls(self, o, mode='all'):
         xfilter0 = lambda i: self._gen_struct_decl(i) is not None
@@ -728,22 +748,13 @@ def visit_Operator(self, o, mode='all'):
             efuncs.extend([self._visit(i), blankline])
 
         # Definitions
-        headers = []
-        for h in o._headers:
-            try:
-                headers.append(c.Define(*h))
-            except TypeError:
-                # Plain string
-                headers.append(c.Line(h))
-        headers = headers + [blankline]
+        headers = self._operator_headers(o)
 
         # Header files
-        includes = self._operator_includes(o) + [blankline]
+        includes = self._operator_includes(o)
 
         # Namespaces
-        namespaces = [self._visit(i) for i in o._namespaces]
-        if namespaces:
-            namespaces.append(blankline)
+        namespaces = self._operator_namespaces(o)
 
         # Type declarations
         typedecls = self._operator_typedecls(o, mode)
@@ -1003,8 +1014,8 @@ def _defines_aliases(n):
     rules = {
         'symbolics': lambda n: n.functions,
         'basics': lambda n: [i for i in n.expr_symbols if isinstance(i, Basic)],
-        'abstractsymbols': lambda n: [i for i in n.expr_symbols
-                                      if isinstance(i, AbstractSymbol)],
+        'symbols': lambda n: [i for i in n.expr_symbols
+                              if isinstance(i, AbstractSymbol)],
         'dimensions': lambda n: [i for i in n.expr_symbols if isinstance(i, Dimension)],
         'indexeds': lambda n: [i for i in n.expr_symbols if i.is_Indexed],
         'indexedbases': lambda n: [i for i in n.expr_symbols

devito/operator/operator.py

@@ -144,10 +144,6 @@ class Operator(Callable):
     refer to the relevant documentation.
     """
 
-    _default_headers = [('_POSIX_C_SOURCE', '200809L')]
-    _default_globals = []
-    _default_namespaces = []
-
     def __new__(cls, expressions, **kwargs):
         if expressions is None:
             # Return a dummy Callable. This is exploited by unpickling. Users
@@ -194,11 +190,6 @@ def _sanitize_exprs(cls, expressions, **kwargs):
 
         return expressions
 
-    @classmethod
-    @property
-    def _default_includes(cls):
-        return cls._Target.Printer._default_includes
-
     @classmethod
     def _build(cls, expressions, **kwargs):
         # Python- (i.e., compile-) and C-level (i.e., run-time) performance
@@ -212,15 +203,11 @@ def _build(cls, expressions, **kwargs):
         Callable.__init__(op, **op.args)
 
         # Header files, etc.
-        op._headers = OrderedSet(*cls._default_headers)
-        op._headers.update(byproduct.headers)
-        op._globals = OrderedSet(*cls._default_globals)
-        op._globals.update(byproduct.globals)
-        op._includes = OrderedSet(*cls._default_includes)
-        op._includes.update(profiler._default_includes)
+        op._headers = OrderedSet(*byproduct.headers)
+        op._globals = OrderedSet(*byproduct.globals)
+        op._includes = OrderedSet(*profiler._default_includes)
         op._includes.update(byproduct.includes)
-        op._namespaces = OrderedSet(*cls._default_namespaces)
-        op._namespaces.update(byproduct.namespaces)
+        op._namespaces = OrderedSet(*byproduct.namespaces)
 
         # Required for the jit-compilation
         op._compiler = kwargs['compiler']
@@ -273,6 +260,9 @@ 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('printer', cls._Target.Printer)
 
         expressions = as_tuple(expressions)
 
@@ -480,7 +470,6 @@ def _lower_iet(cls, uiet, profiler=None, **kwargs):
             * Finalize (e.g., symbol definitions, array casts)
         """
         name = kwargs.get("name", "Kernel")
-        lang = cls._Target.lang()
 
         # Wrap the IET with an EntryFunction (a special Callable representing
         # the entry point of the generated library)
@@ -497,10 +486,10 @@ def _lower_iet(cls, uiet, profiler=None, **kwargs):
         cls._Target.instrument(graph, profiler=profiler, **kwargs)
 
         # Extract the necessary macros from the symbolic objects
-        generate_macros(graph, lang=lang, printer=cls._Target.Printer, **kwargs)
+        generate_macros(graph, **kwargs)
 
         # Add type specific metadata
-        lower_dtypes(graph, lang=lang, **kwargs)
+        lower_dtypes(graph, **kwargs)
 
         # Target-independent optimizations
         minimize_symbols(graph)
@@ -779,6 +768,18 @@ def _soname(self):
     def _printer(self):
         return self._Target.Printer
 
+    @cached_property
+    def headers(self):
+        return OrderedSet(*self._printer._headers).union(self._headers)
+
+    @cached_property
+    def includes(self):
+        return OrderedSet(*self._printer._includes).union(self._includes)
+
+    @cached_property
+    def namespaces(self):
+        return OrderedSet(*self._printer._namespaces).union(self._namespaces)
+
     @cached_property
     def ccode(self):
         from devito.ir.iet.visitors import CGen

devito/passes/clusters/cse.py

@@ -70,12 +70,12 @@ def cse(cluster, sregistry=None, options=None, **kwargs):
     """
     min_cost = options['cse-min-cost']
     mode = options['cse-algo']
-    mindtype = np.promote_types(options['scalar-min-type'], cluster.dtype).type
+    dtype = np.promote_types(options['scalar-min-type'], cluster.dtype).type
 
     if cluster.is_fence:
         return cluster
 
-    make = lambda: CTemp(name=sregistry.make_name(), dtype=mindtype)
+    make = lambda: CTemp(name=sregistry.make_name(), dtype=dtype)
 
     exprs = _cse(cluster, make, min_cost=min_cost, mode=mode)
 

devito/passes/iet/languages/C.py

@@ -13,6 +13,9 @@
 class CBB(LangBB):
 
     mapper = {
+        # Complex
+        'includes-complex': 'complex.h',
+        # Allocs
         'header-memcpy': 'string.h',
         'host-alloc': lambda i, j, k:
             Call('posix_memalign', (i, j, k)),
@@ -24,8 +27,6 @@ class CBB(LangBB):
             Call('free', (i,)),
         'alloc-global-symbol': lambda i, j, k:
             Call('memcpy', (i, j, k)),
-        # Complex
-        'includes-complex': 'complex.h',
     }
 
 
@@ -44,7 +45,7 @@ class CPrinter(BasePrinter, C99CodePrinter):
     _func_litterals = {np.float32: 'f', np.complex64: 'f'}
     _func_prefix = {np.float32: 'f', np.float64: 'f',
                     np.complex64: 'c', np.complex128: 'c'}
-    _default_includes = ['stdlib.h', 'math.h', 'sys/time.h']
+    _includes = ['stdlib.h', 'math.h', 'sys/time.h']
 
     # These cannot go through _print_xxx because they are classes not
     # instances

devito/passes/iet/languages/CXX.py

@@ -63,6 +63,11 @@ def std_arith(qualifier=None):
 class CXXBB(LangBB):
 
     mapper = {
+        # Complex
+        'includes-complex': 'complex',
+        'complex-namespace': [UsingNamespace('std::complex_literals')],
+        'def-complex': std_arith(),
+        # Allocs
         'header-memcpy': 'string.h',
         'header-algorithm': 'algorithm',
         'host-alloc': lambda i, j, k:
@@ -75,10 +80,6 @@ class CXXBB(LangBB):
             Call('free', (i,)),
         'alloc-global-symbol': lambda i, j, k:
             Call('memcpy', (i, j, k)),
-        # Complex
-        'includes-complex': 'complex',
-        'complex-namespace': [UsingNamespace('std::complex_literals')],
-        'def-complex': std_arith(),
     }
 
 
@@ -90,7 +91,7 @@ class CXXPrinter(BasePrinter, CXX11CodePrinter):
     _func_litterals = {}
     _func_prefix = {np.float32: 'f', np.float64: 'f'}
     _restrict_keyword = '__restrict'
-    _default_includes = ['stdlib.h', 'cmath', 'sys/time.h']
+    _includes = ['stdlib.h', 'cmath', 'sys/time.h']
 
     # These cannot go through _print_xxx because they are classes not
     # instances

devito/passes/iet/languages/targets.py

@@ -23,7 +23,7 @@ def lang(cls):
 
     @classmethod
     def instrument(cls, *args, **kwargs):
-        instrument(*args, lang=cls.lang(), **kwargs)
+        instrument(*args, **kwargs)
 
 
 class CTarget(Target):

devito/symbolics/inspection.py

@@ -144,6 +144,8 @@ def wrapper(expr, estimate, seen):
 def _estimate_cost(expr, estimate, seen):
     # Retval: flops (int), flag (bool)
     # The flag tells wether it's an integer expression (implying flops==0) or not
+    if not expr.args:
+        return 0, False
     flops, flags = zip(*[_estimate_cost(a, estimate, seen) for a in expr.args])
     flops = sum(flops)
     if all(flags):