Small fix

Author: etotmeni

dpctl-capi/tests/test_sycl_device_aspects.cpp

@@ -75,25 +75,32 @@ auto build_params()
 
     constexpr auto param_2 =
         get_param_list<std::pair<const char *, cl::sycl::aspect>>(
-            // clang-format off
-            std::make_pair("host", cl::sycl::aspect::host), 
-            std::make_pair("cpu", cl::sycl::aspect::cpu), 
+            std::make_pair("host", cl::sycl::aspect::host),
+            std::make_pair("cpu", cl::sycl::aspect::cpu),
             std::make_pair("gpu", cl::sycl::aspect::gpu),
             std::make_pair("accelerator", cl::sycl::aspect::accelerator),
             std::make_pair("custom", cl::sycl::aspect::custom),
-            std::make_pair("fp16", cl::sycl::aspect::fp16), 
+            std::make_pair("fp16", cl::sycl::aspect::fp16),
             std::make_pair("fp64", cl::sycl::aspect::fp64),
-            std::make_pair("int64_base_atomics", cl::sycl::aspect::int64_base_atomics),
-            std::make_pair("int64_extended_atomics", cl::sycl::aspect::int64_extended_atomics),
-            std::make_pair("online_compiler", cl::sycl::aspect::online_compiler),
+            std::make_pair("int64_base_atomics",
+                           cl::sycl::aspect::int64_base_atomics),
+            std::make_pair("int64_extended_atomics",
+                           cl::sycl::aspect::int64_extended_atomics),
+            std::make_pair("online_compiler",
+                           cl::sycl::aspect::online_compiler),
             std::make_pair("online_linker", cl::sycl::aspect::online_linker),
-            std::make_pair("queue_profiling", cl::sycl::aspect::queue_profiling),
-            std::make_pair("usm_device_allocations", cl::sycl::aspect::usm_device_allocations),
-            std::make_pair("usm_host_allocations", cl::sycl::aspect::usm_host_allocations),
-            std::make_pair("usm_shared_allocations", cl::sycl::aspect::usm_shared_allocations),
-            std::make_pair("usm_restricted_shared_allocations", cl::sycl::aspect::usm_restricted_shared_allocations),
-            std::make_pair("usm_system_allocator", cl::sycl::aspect::usm_system_allocator));
-    // clang-format on
+            std::make_pair("queue_profiling",
+                           cl::sycl::aspect::queue_profiling),
+            std::make_pair("usm_device_allocations",
+                           cl::sycl::aspect::usm_device_allocations),
+            std::make_pair("usm_host_allocations",
+                           cl::sycl::aspect::usm_host_allocations),
+            std::make_pair("usm_shared_allocations",
+                           cl::sycl::aspect::usm_shared_allocations),
+            std::make_pair("usm_restricted_shared_allocations",
+                           cl::sycl::aspect::usm_restricted_shared_allocations),
+            std::make_pair("usm_system_allocator",
+                           cl::sycl::aspect::usm_system_allocator));
 
     auto pairs =
         build_param_pairs<const char *,

dpctl/_sycl_device.pyx

@@ -380,92 +380,92 @@ cdef class SyclDevice(_SyclDevice):
             )
 
     @property
-    def aspect_host(self):
+    def has_aspect_host(self):
         cdef _aspect_type AT = _aspect_type._host
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_cpu(self):
+    def has_aspect_cpu(self):
         cdef _aspect_type AT = _aspect_type._cpu
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_gpu(self):
+    def has_aspect_gpu(self):
         cdef _aspect_type AT = _aspect_type._gpu
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_accelerator(self):
+    def has_aspect_accelerator(self):
         cdef _aspect_type AT = _aspect_type._accelerator
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_custom(self):
+    def has_aspect_custom(self):
         cdef _aspect_type AT = _aspect_type._custom
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_fp16(self):
+    def has_aspect_fp16(self):
         cdef _aspect_type AT = _aspect_type._fp16
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_fp64(self):
+    def has_aspect_fp64(self):
         cdef _aspect_type AT = _aspect_type._fp64
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_int64_base_atomics(self):
+    def has_aspect_int64_base_atomics(self):
         cdef _aspect_type AT = _aspect_type._int64_base_atomics
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_int64_extended_atomics(self):
+    def has_aspect_int64_extended_atomics(self):
         cdef _aspect_type AT = _aspect_type._int64_extended_atomics
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_image(self):
+    def has_aspect_image(self):
         cdef _aspect_type AT = _aspect_type._image
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_online_compiler(self):
+    def has_aspect_online_compiler(self):
         cdef _aspect_type AT = _aspect_type._online_compiler
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_online_linker(self):
+    def has_aspect_online_linker(self):
         cdef _aspect_type AT = _aspect_type._online_linker
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_queue_profiling(self):
+    def has_aspect_queue_profiling(self):
         cdef _aspect_type AT = _aspect_type._queue_profiling
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_usm_device_allocations(self):
+    def has_aspect_usm_device_allocations(self):
         cdef _aspect_type AT = _aspect_type._usm_device_allocations
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_usm_host_allocations(self):
+    def has_aspect_usm_host_allocations(self):
         cdef _aspect_type AT = _aspect_type._usm_host_allocations
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_usm_shared_allocations(self):
+    def has_aspect_usm_shared_allocations(self):
         cdef _aspect_type AT = _aspect_type._usm_shared_allocations
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_usm_restricted_shared_allocations(self):
+    def has_aspect_usm_restricted_shared_allocations(self):
         cdef _aspect_type AT = _aspect_type._usm_restricted_shared_allocations
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 
     @property
-    def aspect_usm_system_allocator(self):
+    def has_aspect_usm_system_allocator(self):
         cdef _aspect_type AT = _aspect_type._usm_system_allocator
         return DPCTLDevice_HasAspect(self._device_ref, AT)
 

dpctl/tests/test_sycl_device.py

@@ -88,128 +88,128 @@ def check_get_max_num_sub_groups(device):
 
 def check_has_aspect_host(device):
     try:
-        device.aspect_host
+        device.has_aspect_host
     except Exception:
-        pytest.fail("aspect_host call failed")
+        pytest.fail("has_aspect_host call failed")
 
 
 def check_has_aspect_cpu(device):
     try:
-        device.aspect_cpu
+        device.has_aspect_cpu
     except Exception:
-        pytest.fail("aspect_cpu call failed")
+        pytest.fail("has_aspect_cpu call failed")
 
 
 def check_has_aspect_gpu(device):
     try:
-        device.aspect_gpu
+        device.has_aspect_gpu
     except Exception:
-        pytest.fail("aspect_gpu call failed")
+        pytest.fail("has_aspect_gpu call failed")
 
 
 def check_has_aspect_accelerator(device):
     try:
-        device.aspect_accelerator
+        device.has_aspect_accelerator
     except Exception:
-        pytest.fail("aspect_accelerator call failed")
+        pytest.fail("has_aspect_accelerator call failed")
 
 
 def check_has_aspect_custom(device):
     try:
-        device.aspect_custom
+        device.has_aspect_custom
     except Exception:
-        pytest.fail("aspect_custom call failed")
+        pytest.fail("has_aspect_custom call failed")
 
 
 def check_has_aspect_fp16(device):
     try:
-        device.aspect_fp16
+        device.has_aspect_fp16
     except Exception:
-        pytest.fail("aspect_fp16 call failed")
+        pytest.fail("has_aspect_fp16 call failed")
 
 
 def check_has_aspect_fp64(device):
     try:
-        device.aspect_fp64
+        device.has_aspect_fp64
     except Exception:
-        pytest.fail("aspect_fp64 call failed")
+        pytest.fail("has_aspect_fp64 call failed")
 
 
 def check_has_aspect_int64_base_atomics(device):
     try:
-        device.aspect_int64_base_atomics
+        device.has_aspect_int64_base_atomics
     except Exception:
-        pytest.fail("aspect_int64_base_atomics call failed")
+        pytest.fail("has_aspect_int64_base_atomics call failed")
 
 
 def check_has_aspect_int64_extended_atomics(device):
     try:
-        device.aspect_int64_extended_atomics
+        device.has_aspect_int64_extended_atomics
     except Exception:
-        pytest.fail("aspect_int64_extended_atomics call failed")
+        pytest.fail("has_aspect_int64_extended_atomics call failed")
 
 
 def check_has_aspect_image(device):
     try:
-        device.aspect_image
+        device.has_aspect_image
     except Exception:
-        pytest.fail("aspect_image call failed")
+        pytest.fail("has_aspect_image call failed")
 
 
 def check_has_aspect_online_compiler(device):
     try:
-        device.aspect_online_compiler
+        device.has_aspect_online_compiler
     except Exception:
-        pytest.fail("aspect_online_compiler call failed")
+        pytest.fail("has_aspect_online_compiler call failed")
 
 
 def check_has_aspect_online_linker(device):
     try:
-        device.aspect_online_linker
+        device.has_aspect_online_linker
     except Exception:
-        pytest.fail("aspect_online_linker call failed")
+        pytest.fail("has_aspect_online_linker call failed")
 
 
 def check_has_aspect_queue_profiling(device):
     try:
-        device.aspect_queue_profiling
+        device.has_aspect_queue_profiling
     except Exception:
-        pytest.fail("aspect_queue_profiling call failed")
+        pytest.fail("has_aspect_queue_profiling call failed")
 
 
 def check_has_aspect_usm_device_allocations(device):
     try:
-        device.aspect_usm_device_allocations
+        device.has_aspect_usm_device_allocations
     except Exception:
-        pytest.fail("aspect_usm_device_allocations call failed")
+        pytest.fail("has_aspect_usm_device_allocations call failed")
 
 
 def check_has_aspect_usm_host_allocations(device):
     try:
-        device.aspect_usm_host_allocations
+        device.has_aspect_usm_host_allocations
     except Exception:
-        pytest.fail("aspect_usm_host_allocations call failed")
+        pytest.fail("has_aspect_usm_host_allocations call failed")
 
 
 def check_has_aspect_usm_shared_allocations(device):
     try:
-        device.aspect_usm_shared_allocations
+        device.has_aspect_usm_shared_allocations
     except Exception:
-        pytest.fail("aspect_usm_shared_allocations call failed")
+        pytest.fail("has_aspect_usm_shared_allocations call failed")
 
 
 def check_has_aspect_usm_restricted_shared_allocations(device):
     try:
-        device.aspect_usm_restricted_shared_allocations
+        device.has_aspect_usm_restricted_shared_allocations
     except Exception:
-        pytest.fail("aspect_usm_restricted_shared_allocations call failed")
+        pytest.fail("has_aspect_usm_restricted_shared_allocations call failed")
 
 
 def check_has_aspect_usm_system_allocator(device):
     try:
-        device.aspect_usm_system_allocator
+        device.has_aspect_usm_system_allocator
     except Exception:
-        pytest.fail("aspect_usm_system_allocator call failed")
+        pytest.fail("has_aspect_usm_system_allocator call failed")
 
 
 def check_is_accelerator(device):