arch: add intel gpu basic gpu_info support

Author: mloubout

devito/arch/archinfo.py

@@ -330,6 +330,67 @@ def cbk(deviceid=0):
     except OSError:
         pass
 
+    # *** Third try: `sycl-ls`
+    try:
+        gpu_infos = {}
+
+        # sycl-ls sometimes finds gpu twice with opencl and without so
+        # we need to make sure we don't get duplicates
+        selected_platform = None
+        platform_block = ""
+
+        proc = Popen(["sycl-ls", "--verbose"], stdout=PIPE, stderr=DEVNULL, text=True)
+        sycl_output, _ = proc.communicate()
+
+        # Extract platform blocks
+        platforms = re.findall(r"Platform \[#(\d+)\]:([\s\S]*?)(?=Platform \[#\d+\]:|$)",
+                               sycl_output)
+
+        # Select Level-Zero if available, otherwise use OpenCL
+        for platform_id, platform_content in platforms:
+            if "Intel(R) Level-Zero" in platform_content:
+                selected_platform = platform_id
+                platform_block = platform_content
+                break
+            elif "Intel(R) OpenCL Graphics" in platform_content and \
+                    selected_platform is None:
+                selected_platform = platform_id
+                platform_block = platform_content
+
+        # Extract GPU devices from the selected platform
+        devices = re.findall(r"Device \[#(\d+)\]:([\s\S]*?)(?=Device \[#\d+\]:|$)",
+                             platform_block)
+
+        for device_id, device_block in devices:
+            if re.search(r"^\s*Type\s*:\s*gpu", device_block, re.MULTILINE):
+                name_match = re.search(r"^\s*Name\s*:\s*(.+)", device_block, re.MULTILINE)
+
+                if name_match:
+                    name = name_match.group(1).strip()
+
+                    # Store GPU info with correct physical ID
+                    gpu_infos[device_id] = {
+                        "physicalid": device_id,
+                        "product": name
+                    }
+
+        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
+        # it throws a lot of weird errors in docker so skipping for now
+        for i in ['total', 'free', 'used']:
+            def make_cbk(i):
+                def cbk(deviceid=0):
+                    return None
+            gpu_info['mem.%s' % i] = make_cbk(i)
+
+        gpu_infos['architecture'] = 'Intel'
+        return gpu_info
+
+    except OSError:
+        pass
+
     # *** Second try: `lshw`
     try:
         info_cmd = ['lshw', '-C', 'video']
@@ -391,7 +452,8 @@ def parse_product_arch():
         gpu_infos = []
         for line in lines:
             # Graphics cards are listed as VGA or 3D controllers in lspci
-            if 'VGA' in line or '3D' in line:
+            if 'VGA' in line or '3D' in line or 'Display' in line:
+                print(line)
                 gpu_info = {}
                 # Lines produced by lspci command are of the form:
                 #   xxxx:xx:xx.x Device Type: Name

devito/arch/compiler.py

@@ -915,7 +915,7 @@ def __init_finalize__(self, **kwargs):
         elif isinstance(platform, IntelDevice):
             self.cflags.append('-fsycl-targets=spir64')
         else:
-            raise NotImplementedError(f"Unsupported platform {platform}")
+            warning(f"Unsupported platform {platform}")
 
 
 class CustomCompiler(Compiler):

devito/ir/cgen/printer.py

@@ -17,7 +17,7 @@
 from devito.arch.compiler import AOMPCompiler
 from devito.symbolics.inspection import has_integer_args, sympy_dtype
 from devito.types.basic import AbstractFunction
-from devito.tools import ctypes_to_cstr, dtype_to_ctype
+from devito.tools import ctypes_to_cstr, dtype_to_ctype, ctypes_vector_mapper
 
 __all__ = ['BasePrinter', 'ccode']
 
@@ -118,6 +118,9 @@ def _print_type(self, expr):
         except KeyError:
             return ctypes_to_cstr(expr)
 
+    def _print_VoidDType(self, expr):
+        return ctypes_vector_mapper[expr].__name__
+
     def _print_Function(self, expr):
         if isinstance(expr, AbstractFunction):
             return str(expr)

devito/passes/iet/languages/C.py

@@ -24,7 +24,7 @@ class CBB(LangBB):
             Call('free', (i,)),
         'alloc-global-symbol': lambda i, j, k:
             Call('memcpy', (i, j, k)),
-        # Complex and float16
+        # Complex
         'includes-complex': 'complex.h',
     }
 

devito/passes/iet/languages/CXX.py

@@ -8,39 +8,44 @@
 __all__ = ['CXXBB']
 
 
-std_arith = """
+def std_arith(qualifier=None):
+    if qualifier:
+        qual = qualifier if qualifier.endswith(" ") else f"{qualifier} "
+    else:
+        qual = ""
+    return f"""
 #include <complex>
 
 template<typename _Tp, typename _Ti>
-std::complex<_Tp> operator * (const _Ti & a, const std::complex<_Tp> & b){
+{qual}std::complex<_Tp> operator * (const _Ti & a, const std::complex<_Tp> & b){{
   return std::complex<_Tp>(b.real() * a, b.imag() * a);
-}
+}}
 
 template<typename _Tp, typename _Ti>
-std::complex<_Tp> operator * (const std::complex<_Tp> & b, const _Ti & a){
+{qual}std::complex<_Tp> operator * (const std::complex<_Tp> & b, const _Ti & a){{
   return std::complex<_Tp>(b.real() * a, b.imag() * a);
-}
+}}
 
 template<typename _Tp, typename _Ti>
-std::complex<_Tp> operator / (const _Ti & a, const std::complex<_Tp> & b){
-  _Tp denom = b.real() * b.real () + b.imag() * b.imag()
+{qual}std::complex<_Tp> operator / (const _Ti & a, const std::complex<_Tp> & b){{
+  _Tp denom = b.real() * b.real () + b.imag() * b.imag();
   return std::complex<_Tp>(b.real() * a / denom, - b.imag() * a / denom);
-}
+}}
 
 template<typename _Tp, typename _Ti>
-std::complex<_Tp> operator / (const std::complex<_Tp> & b, const _Ti & a){
+{qual}std::complex<_Tp> operator / (const std::complex<_Tp> & b, const _Ti & a){{
   return std::complex<_Tp>(b.real() / a, b.imag() / a);
-}
+}}
 
 template<typename _Tp, typename _Ti>
-std::complex<_Tp> operator + (const _Ti & a, const std::complex<_Tp> & b){
+{qual}std::complex<_Tp> operator + (const _Ti & a, const std::complex<_Tp> & b){{
   return std::complex<_Tp>(b.real() + a, b.imag());
-}
+}}
 
 template<typename _Tp, typename _Ti>
-std::complex<_Tp> operator + (const std::complex<_Tp> & b, const _Ti & a){
+{qual}std::complex<_Tp> operator + (const std::complex<_Tp> & b, const _Ti & a){{
   return std::complex<_Tp>(b.real() + a, b.imag());
-}
+}}
 
 """
 
@@ -60,10 +65,10 @@ class CXXBB(LangBB):
             Call('free', (i,)),
         'alloc-global-symbol': lambda i, j, k:
             Call('memcpy', (i, j, k)),
-        # Complex and float16
+        # Complex
         'includes-complex': 'complex',
         'complex-namespace': [UsingNamespace('std::complex_literals')],
-        'def-complex': std_arith,
+        'def-complex': std_arith(),
     }
 
 

devito/symbolics/extended_dtypes.py

@@ -61,22 +61,11 @@ class CustomType(ReservedWord):
     pass
 
 
-# Dynamically create INT, INT2, .... INTP, INT2P, ... FLOAT, ...
-for base_name in ['int', 'float', 'double']:
-    for i in ['', '2', '3', '4']:
-        v = '%s%s' % (base_name, i)
-        cls = type(v.upper(), (Cast,), {'_base_typ': v})
-        globals()[cls.__name__] = cls
-
-        clsp = type('%sP' % v.upper(), (Cast,), {'base': cls})
-        globals()[clsp.__name__] = clsp
-
-
 def cast_mapper(arg):
     try:
         assert len(arg) == 2 and arg[1] == '*'
         return lambda v, dtype=None, **kw: Cast(v, dtype=arg[0], stars=arg[1], **kw)
-    except TypeError:
+    except (AssertionError, TypeError):
         return lambda v, dtype=None, **kw: Cast(v, dtype=arg, **kw)
 
 
@@ -102,3 +91,11 @@ class VOID(BaseCast):
 class INT(BaseCast):
 
     _dtype = np.int32
+
+
+# Dynamically create INT, INT2, .... INTP, INT2P, ... FLOAT, ...
+for base_name in ['int', 'float', 'double']:
+    for i in ['2', '3', '4']:
+        v = '%s%s' % (base_name, i)
+        globals()[v.upper()] = cast_mapper(v)
+        globals()[f'{v.upper()}P'] = cast_mapper((v, '*'))

devito/symbolics/manipulation.py

@@ -128,7 +128,10 @@ def _(mapper, rule):
 
 @singledispatch
 def _uxreplace_handle(expr, args, kwargs):
-    return expr.func(*args)
+    try:
+        return expr.func(*args, evaluate=False)
+    except TypeError:
+        return expr.func(*args)
 
 
 @_uxreplace_handle.register(Min)

devito/tools/dtypes_lowering.py

@@ -236,7 +236,8 @@ class c_restrict_void_p(ctypes.c_void_p):
 
         name = "%s%d" % (base_name, count)
         ctype = type(name, (ctypes.Structure,),
-                     {'_fields_': [(i, base_ctype)] for i in field_names[:count]})
+                     {'_fields_': [(i, base_ctype) for i in field_names[:count]],
+                      '_base_dtype': True})
 
         ctypes_vector_mapper[dtype] = ctype
 

devito/types/object.py

@@ -54,6 +54,7 @@ def _sympystr(self, printer):
         return str(self)
 
     _ccode = _sympystr
+    _cxxcode = _sympystr
 
     def _hashable_content(self):
         return (self.name, self.dtype)