Replace sycl::cl_* -> sycl::opencl::cl_*

KhronosGroup · Sep 11, 2024 · f78de65 · f78de65
1 parent f0f71db
commit f78de65
Show file tree

Hide file tree

Showing 20 changed files with 147 additions and 147 deletions.
diff --git a/tests/accessor_legacy/accessor_constructors_buffer_utility.h b/tests/accessor_legacy/accessor_constructors_buffer_utility.h
@@ -341,7 +341,7 @@ class buffer_accesor_input_data {
 
   using range_t = sycl::range<dataDims>;
   using offset_t = sycl::id<dataDims>;
-  using data_t = std::vector<sycl::cl_uchar>;
+  using data_t = std::vector<sycl::opencl::cl_uchar>;
   using buffer_t = sycl::buffer<T, dataDims, allocatorT...>;
 
 public:
@@ -384,7 +384,7 @@ class buffer_accesor_input_data<T, 0, allocatorT...> {
 
   using range_t = sycl::range<dataDims>;
   using offset_t = sycl::id<dataDims>;
-  using data_t = std::vector<sycl::cl_uchar>;
+  using data_t = std::vector<sycl::opencl::cl_uchar>;
   using buffer_t = sycl::buffer<T, dataDims, allocatorT...>;
 
 public:

diff --git a/tests/accessor_legacy/accessor_types_core.h b/tests/accessor_legacy/accessor_types_core.h
@@ -82,49 +82,49 @@ class check_all_types_core {
                         "user alias");
 
 #ifdef INT8_MAX
-    if (!std::is_same<std::int8_t, sycl::cl_char>::value) {
+    if (!std::is_same<std::int8_t, sycl::opencl::cl_char>::value) {
       for_type_and_vectors<check_type, std::int8_t>(
           log, queue, "std::int8_t");
     }
 #endif
 #ifdef UINT8_MAX
-    if (!std::is_same<std::uint8_t, sycl::cl_uchar>::value) {
+    if (!std::is_same<std::uint8_t, sycl::opencl::cl_uchar>::value) {
       for_type_and_vectors<check_type, std::uint8_t>(
           log, queue, "std::uint8_t");
     }
 #endif
 #ifdef INT16_MAX
-    if (!std::is_same<std::int16_t, sycl::cl_short>::value) {
+    if (!std::is_same<std::int16_t, sycl::opencl::cl_short>::value) {
       for_type_and_vectors<check_type, std::int16_t>(
           log, queue, "std::int16_t");
     }
 #endif
 #ifdef UINT16_MAX
-    if (!std::is_same<std::uint16_t, sycl::cl_ushort>::value) {
+    if (!std::is_same<std::uint16_t, sycl::opencl::cl_ushort>::value) {
       for_type_and_vectors<check_type, std::uint16_t>(
           log, queue, "std::uint16_t");
     }
 #endif
 #ifdef INT32_MAX
-    if (!std::is_same<std::int32_t, sycl::cl_int>::value) {
+    if (!std::is_same<std::int32_t, sycl::opencl::cl_int>::value) {
       for_type_and_vectors<check_type, std::int32_t>(
           log, queue, "std::int32_t");
     }
 #endif
 #ifdef UINT32_MAX
-    if (!std::is_same<std::uint32_t, sycl::cl_uint>::value) {
+    if (!std::is_same<std::uint32_t, sycl::opencl::cl_uint>::value) {
       for_type_and_vectors<check_type, std::uint32_t>(
           log, queue, "std::uint32_t");
     }
 #endif
 #ifdef INT64_MAX
-    if (!std::is_same<std::int64_t, sycl::cl_long>::value) {
+    if (!std::is_same<std::int64_t, sycl::opencl::cl_long>::value) {
       for_type_and_vectors<check_type, std::int64_t>(
           log, queue, "std::int64_t");
     }
 #endif
 #ifdef UINT64_MAX
-    if (!std::is_same<std::uint64_t, sycl::cl_ulong>::value) {
+    if (!std::is_same<std::uint64_t, sycl::opencl::cl_ulong>::value) {
       for_type_and_vectors<check_type, std::uint64_t>(
           log, queue, "std::uint64_t");
     }

diff --git a/tests/accessor_legacy/accessor_types_fp16.h b/tests/accessor_legacy/accessor_types_fp16.h
@@ -55,8 +55,8 @@ class check_all_types_fp16 {
     // Extended type coverage
     for_type_and_vectors<check_type, sycl::half>(
         log, queue, "sycl::half");
-    for_type_and_vectors<check_type, sycl::cl_half>(
-        log, queue, "sycl::cl_half");
+    for_type_and_vectors<check_type, sycl::opencl::cl_half>(
+        log, queue, "sycl::opencl::cl_half");
 
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
 

diff --git a/tests/accessor_legacy/accessor_types_fp64.h b/tests/accessor_legacy/accessor_types_fp64.h
@@ -60,8 +60,8 @@ class check_all_types_fp64 {
     // Extended type coverage
     for_type_and_vectors<check_type, double>(
         log, queue, "double");
-    for_type_and_vectors<check_type, sycl::cl_double>(
-        log, queue, "sycl::cl_double");
+    for_type_and_vectors<check_type, sycl::opencl::cl_double>(
+        log, queue, "sycl::opencl::cl_double");
 
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
 

diff --git a/tests/accessor_legacy/accessor_types_image_core.h b/tests/accessor_legacy/accessor_types_image_core.h
@@ -19,7 +19,7 @@
 
 namespace TEST_NAMESPACE {
 
-using user_alias = sycl::vec<sycl::cl_int, 4>;
+using user_alias = sycl::vec<sycl::opencl::cl_int, 4>;
 
 /**
  *  @brief Run specific image accessors' tests for core type set
@@ -46,13 +46,13 @@ class check_all_types_image_core {
       return;
 
     const auto types =
-        named_type_pack<sycl::cl_int4,
-                        sycl::cl_uint4,
-                        sycl::cl_float4,
+        named_type_pack<sycl::opencl::cl_int4,
+                        sycl::opencl::cl_uint4,
+                        sycl::opencl::cl_float4,
                         user_alias>::generate(
-                        "sycl::cl_int",
-                        "sycl::cl_uint",
-                        "sycl::cl_float",
+                        "sycl::opencl::cl_int",
+                        "sycl::opencl::cl_uint",
+                        "sycl::opencl::cl_float",
                         "user_alias");
 
     for_all_types<check_type>(types, log, queue);

diff --git a/tests/accessor_legacy/accessor_types_image_fp16.h b/tests/accessor_legacy/accessor_types_image_fp16.h
@@ -44,7 +44,7 @@ class check_all_types_image_fp16 {
     if (!availability::check(queue, log))
       return;
 
-    check_type<sycl::cl_half4>()(log, queue, "sycl::cl_half");
+    check_type<sycl::opencl::cl_half4>()(log, queue, "sycl::opencl::cl_half");
 
     queue.wait_and_throw();
   }

diff --git a/tests/buffer/buffer_api_fp16.cpp b/tests/buffer/buffer_api_fp16.cpp
@@ -2,7 +2,7 @@
 //
 //  SYCL 2020 Conformance Test Suite
 //
-// Provides buffer api tests for sycl::half and sycl::cl_half
+// Provides buffer api tests for sycl::half and sycl::opencl::cl_half
 //
 *******************************************************************************/
 
@@ -38,7 +38,7 @@ class TEST_NAME : public util::test_base {
                          sycl::half>(log, "sycl::half");
 #if SYCL_CTS_ENABLE_FULL_CONFORMANCE
     for_type_and_vectors<buffer_api_common::check_buffer_api_for_type,
-                         sycl::cl_half>(log, "sycl::cl_half");
+                         sycl::opencl::cl_half>(log, "sycl::opencl::cl_half");
 #endif // SYCL_CTS_ENABLE_FULL_CONFORMANCE
   }
 };

diff --git a/tests/buffer/buffer_api_fp64.cpp b/tests/buffer/buffer_api_fp64.cpp
@@ -2,7 +2,7 @@
 //
 //  SYCL 2020 Conformance Test Suite
 //
-// Provides buffer api tests for double and sycl::cl_double
+// Provides buffer api tests for double and sycl::opencl::cl_double
 //
 *******************************************************************************/
 
@@ -38,7 +38,7 @@ class TEST_NAME : public util::test_base {
         log, "double");
 #if SYCL_CTS_ENABLE_FULL_CONFORMANCE
     for_type_and_vectors<buffer_api_common::check_buffer_api_for_type,
-                         sycl::cl_double>(log, "sycl::cl_double");
+                         sycl::opencl::cl_double>(log, "sycl::opencl::cl_double");
 #endif // SYCL_CTS_ENABLE_FULL_CONFORMANCE
   }
 };

diff --git a/tests/buffer/buffer_constructors_fp16.cpp b/tests/buffer/buffer_constructors_fp16.cpp
@@ -2,7 +2,7 @@
 //
 //  SYCL 2020 Conformance Test Suite
 //
-// Provides buffer constructors tests for sycl::half and sycl::cl_half
+// Provides buffer constructors tests for sycl::half and sycl::opencl::cl_half
 //
 *******************************************************************************/
 
@@ -40,7 +40,7 @@ class TEST_NAME : public util::test_base {
 #if SYCL_CTS_ENABLE_FULL_CONFORMANCE
     for_type_and_vectors<
         buffer_constructors_common::check_buffer_ctors_for_type,
-        sycl::cl_half>(log, "sycl::cl_half");
+        sycl::opencl::cl_half>(log, "sycl::opencl::cl_half");
 #endif // SYCL_CTS_ENABLE_FULL_CONFORMANCE
   }
 };

diff --git a/tests/buffer/buffer_constructors_fp64.cpp b/tests/buffer/buffer_constructors_fp64.cpp
@@ -2,7 +2,7 @@
 //
 //  SYCL 2020 Conformance Test Suite
 //
-// Provides buffer constructors tests for double and sycl::cl_double
+// Provides buffer constructors tests for double and sycl::opencl::cl_double
 //
 *******************************************************************************/
 
@@ -40,7 +40,7 @@ class TEST_NAME : public util::test_base {
 #if SYCL_CTS_ENABLE_FULL_CONFORMANCE
     for_type_and_vectors<
         buffer_constructors_common::check_buffer_ctors_for_type,
-        sycl::cl_double>(log, "sycl::cl_double");
+        sycl::opencl::cl_double>(log, "sycl::opencl::cl_double");
 #endif // SYCL_CTS_ENABLE_FULL_CONFORMANCE
   }
 };

diff --git a/tests/buffer/buffer_storage_fp16.cpp b/tests/buffer/buffer_storage_fp16.cpp
@@ -3,7 +3,7 @@
 //  SYCL 2020 Conformance Test Suite
 //
 // Provides buffer storage methods tests for sycl::half and
-sycl::cl_half
+sycl::opencl::cl_half
 //
 *******************************************************************************/
 
@@ -39,7 +39,7 @@ class TEST_NAME : public util::test_base {
                          sycl::half>(log, "sycl::half");
 #if SYCL_CTS_ENABLE_FULL_CONFORMANCE
     for_type_and_vectors<buffer_storage_common::check_buffer_storage_for_type,
-                         sycl::cl_half>(log, "sycl::cl_half");
+                         sycl::opencl::cl_half>(log, "sycl::opencl::cl_half");
 #endif // SYCL_CTS_ENABLE_FULL_CONFORMANCE
   }
 };

diff --git a/tests/buffer/buffer_storage_fp64.cpp b/tests/buffer/buffer_storage_fp64.cpp
@@ -2,7 +2,7 @@
 //
 //  SYCL 2020 Conformance Test Suite
 //
-// Provides buffer storage methods tests for double and sycl::cl_double
+// Provides buffer storage methods tests for double and sycl::opencl::cl_double
 //
 *******************************************************************************/
 
@@ -38,7 +38,7 @@ class TEST_NAME : public util::test_base {
                          double>(log, "double");
 #if SYCL_CTS_ENABLE_FULL_CONFORMANCE
     for_type_and_vectors<buffer_storage_common::check_buffer_storage_for_type,
-                         sycl::cl_double>(log, "sycl::cl_double");
+                         sycl::opencl::cl_double>(log, "sycl::opencl::cl_double");
 #endif // SYCL_CTS_ENABLE_FULL_CONFORMANCE
   }
 };

diff --git a/tests/common/common.h b/tests/common/common.h
@@ -430,8 +430,8 @@ struct image_access;
  */
 template <>
 struct image_access<1> {
-  using int_type = sycl::cl_int;
-  using float_type = sycl::cl_float;
+  using int_type = sycl::opencl::cl_int;
+  using float_type = sycl::opencl::cl_float;
   static int_type get_int(const sycl::id<1>& i) {
     return int_type(i.get(0));
   }
@@ -465,8 +465,8 @@ struct image_access<1> {
  */
 template <>
 struct image_access<2> {
-  using int_type = sycl::cl_int2;
-  using float_type = sycl::cl_float2;
+  using int_type = sycl::opencl::cl_int2;
+  using float_type = sycl::opencl::cl_float2;
   static int_type get_int(const sycl::id<2>& i) {
     return int_type(i.get(0), i.get(1));
   }
@@ -503,8 +503,8 @@ struct image_access<2> {
  */
 template <>
 struct image_access<3> {
-  using int_type = sycl::cl_int4;
-  using float_type = sycl::cl_float4;
+  using int_type = sycl::opencl::cl_int4;
+  using float_type = sycl::opencl::cl_float4;
   static int_type get_int(const sycl::id<3>& i) {
     return int_type(i.get(0), i.get(1), i.get(2), 0);
   }

diff --git a/tests/common/type_list.h b/tests/common/type_list.h
@@ -219,22 +219,22 @@ inline auto get_vector_types() {
   static const auto pack = named_type_pack<
       bool, char, signed char, unsigned char, short, unsigned short, int,
       unsigned int, long, unsigned long, long long, unsigned long long, float,
-      sycl::cl_float, sycl::byte, sycl::cl_bool, sycl::cl_char, sycl::cl_uchar,
-      sycl::cl_short, sycl::cl_ushort, sycl::cl_int, sycl::cl_uint,
-      sycl::cl_long, sycl::cl_ulong>::generate("bool", "char", "signed char",
+      sycl::opencl::cl_float, sycl::byte, sycl::opencl::cl_bool, sycl::opencl::cl_char, sycl::opencl::cl_uchar,
+      sycl::opencl::cl_short, sycl::opencl::cl_ushort, sycl::opencl::cl_int, sycl::opencl::cl_uint,
+      sycl::opencl::cl_long, sycl::opencl::cl_ulong>::generate("bool", "char", "signed char",
                                                "unsigned char", "short",
                                                "unsigned short", "int",
                                                "unsigned int", "long",
                                                "unsigned long", "long long",
                                                "unsigned long long", "float",
-                                               "sycl::cl_float", "sycl::byte",
-                                               "sycl::cl_bool", "sycl::cl_char",
-                                               "sycl::cl_uchar",
-                                               "sycl::cl_short",
-                                               "sycl::cl_ushort",
-                                               "sycl::cl_int", "sycl::cl_uint",
-                                               "sycl::cl_long",
-                                               "sycl::cl_ulong");
+                                               "sycl::opencl::cl_float", "sycl::byte",
+                                               "sycl::opencl::cl_bool", "sycl::opencl::cl_char",
+                                               "sycl::opencl::cl_uchar",
+                                               "sycl::opencl::cl_short",
+                                               "sycl::opencl::cl_ushort",
+                                               "sycl::opencl::cl_int", "sycl::opencl::cl_uint",
+                                               "sycl::opencl::cl_long",
+                                               "sycl::opencl::cl_ulong");
 #else
   static const auto pack =
       named_type_pack<bool, char, signed char, unsigned char, short,

diff --git a/tests/group/group_async_work_group_copy.cpp b/tests/group/group_async_work_group_copy.cpp
@@ -57,70 +57,70 @@ class TEST_NAME : public util::test_base {
     for_type_and_vectors<check_type, sycl::byte>(log, "sycl::byte");
 
 #if SYCL_CTS_ENABLE_OPENCL_INTEROP_TESTS
-    for_type_and_vectors<check_type, sycl::cl_bool>(log, "sycl::cl_bool");
-    for_type_and_vectors<check_type, sycl::cl_char>(log, "sycl::cl_char");
-    for_type_and_vectors<check_type, sycl::cl_uchar>(log, "sycl::cl_uchar");
-    for_type_and_vectors<check_type, sycl::cl_short>(log, "sycl::cl_short");
-    for_type_and_vectors<check_type, sycl::cl_ushort>(log, "sycl::cl_ushort");
-    for_type_and_vectors<check_type, sycl::cl_int>(log, "sycl::cl_int");
-    for_type_and_vectors<check_type, sycl::cl_uint>(log, "sycl::cl_uint");
-    for_type_and_vectors<check_type, sycl::cl_long>(log, "sycl::cl_long");
-    for_type_and_vectors<check_type, sycl::cl_ulong>(log, "sycl::cl_ulong");
-    for_type_and_vectors<check_type, sycl::cl_float>(log, "sycl::cl_float");
+    for_type_and_vectors<check_type, sycl::opencl::cl_bool>(log, "sycl::opencl::cl_bool");
+    for_type_and_vectors<check_type, sycl::opencl::cl_char>(log, "sycl::opencl::cl_char");
+    for_type_and_vectors<check_type, sycl::opencl::cl_uchar>(log, "sycl::opencl::cl_uchar");
+    for_type_and_vectors<check_type, sycl::opencl::cl_short>(log, "sycl::opencl::cl_short");
+    for_type_and_vectors<check_type, sycl::opencl::cl_ushort>(log, "sycl::opencl::cl_ushort");
+    for_type_and_vectors<check_type, sycl::opencl::cl_int>(log, "sycl::opencl::cl_int");
+    for_type_and_vectors<check_type, sycl::opencl::cl_uint>(log, "sycl::opencl::cl_uint");
+    for_type_and_vectors<check_type, sycl::opencl::cl_long>(log, "sycl::opencl::cl_long");
+    for_type_and_vectors<check_type, sycl::opencl::cl_ulong>(log, "sycl::opencl::cl_ulong");
+    for_type_and_vectors<check_type, sycl::opencl::cl_float>(log, "sycl::opencl::cl_float");
 #endif
 
 #ifdef INT8_MAX
 #if SYCL_CTS_ENABLE_OPENCL_INTEROP_TESTS
-    if (!std::is_same<sycl::cl_char, std::int8_t>::value)
+    if (!std::is_same<sycl::opencl::cl_char, std::int8_t>::value)
 #endif
       for_type_and_vectors<check_type, std::int8_t>(log, "std::int8_t");
 #endif
 
 #ifdef INT16_MAX
 #if SYCL_CTS_ENABLE_OPENCL_INTEROP_TESTS
-    if (!std::is_same<sycl::cl_short, std::int16_t>::value)
+    if (!std::is_same<sycl::opencl::cl_short, std::int16_t>::value)
 #endif
       for_type_and_vectors<check_type, std::int16_t>(log, "std::int16_t");
 #endif
 
 #ifdef INT32_MAX
 #if SYCL_CTS_ENABLE_OPENCL_INTEROP_TESTS
-    if (!std::is_same<sycl::cl_int, std::int32_t>::value)
+    if (!std::is_same<sycl::opencl::cl_int, std::int32_t>::value)
 #endif
       for_type_and_vectors<check_type, std::int32_t>(log, "std::int32_t");
 #endif
 
 #ifdef INT64_MAX
 #if SYCL_CTS_ENABLE_OPENCL_INTEROP_TESTS
-    if (!std::is_same<sycl::cl_long, std::int64_t>::value)
+    if (!std::is_same<sycl::opencl::cl_long, std::int64_t>::value)
 #endif
       for_type_and_vectors<check_type, std::int64_t>(log, "std::int64_t");
 #endif
 
 #ifdef UINT8_MAX
 #if SYCL_CTS_ENABLE_OPENCL_INTEROP_TESTS
-    if (!std::is_same<sycl::cl_uchar, std::uint8_t>::value)
+    if (!std::is_same<sycl::opencl::cl_uchar, std::uint8_t>::value)
 #endif
       for_type_and_vectors<check_type, std::uint8_t>(log, "std::uint8_t");
 #endif
 
 #ifdef UINT16_MAX
 #if SYCL_CTS_ENABLE_OPENCL_INTEROP_TESTS
-    if (!std::is_same<sycl::cl_ushort, std::uint16_t>::value)
+    if (!std::is_same<sycl::opencl::cl_ushort, std::uint16_t>::value)
 #endif
       for_type_and_vectors<check_type, std::uint16_t>(log, "std::uint16_t");
 #endif
 
 #ifdef UINT32_MAX
 #if SYCL_CTS_ENABLE_OPENCL_INTEROP_TESTS
-    if (!std::is_same<sycl::cl_uint, std::uint32_t>::value)
+    if (!std::is_same<sycl::opencl::cl_uint, std::uint32_t>::value)
 #endif
       for_type_and_vectors<check_type, std::uint32_t>(log, "std::uint32_t");
 #endif
 
 #ifdef UINT64_MAX
 #if SYCL_CTS_ENABLE_OPENCL_INTEROP_TESTS
-    if (!std::is_same<sycl::cl_ulong, std::uint64_t>::value)
+    if (!std::is_same<sycl::opencl::cl_ulong, std::uint64_t>::value)
 #endif
       for_type_and_vectors<check_type, std::uint64_t>(log, "std::uint64_t");
 #endif