[SYCL] Do not use cl_* types in DeviceLib tests (#1555)

`cl_*` types are only defined by SYCL 2020 spec for interoperability
with OpenCL backend. We should be focusing on core SYCL types instead.

Author: AlexeySachkov

SYCL/DeviceLib/built-ins/nan.cpp

@@ -38,10 +38,10 @@ template <typename T, typename R> void check_nan(s::queue &Queue) {
 }
 
 int main() {
-  test_nan_call<s::ushort, s::half>();
-  test_nan_call<s::uint, float>();
-  test_nan_call<s::ulong, double>();
-  test_nan_call<s::ulonglong, double>();
+  test_nan_call<unsigned short, s::half>();
+  test_nan_call<unsigned int, float>();
+  test_nan_call<unsigned long, double>();
+  test_nan_call<unsigned long long, double>();
   test_nan_call<s::ushort2, s::half2>();
   test_nan_call<s::uint2, s::float2>();
   test_nan_call<s::ulong2, s::double2>();

SYCL/DeviceLib/built-ins/scalar_common.cpp

@@ -12,14 +12,14 @@ namespace s = sycl;
 int main() {
   // max
   {
-    s::cl_float r{0};
+    float r{0};
     {
-      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::buffer<float, 1> BufR(&r, s::range<1>(1));
       s::queue myQueue;
       myQueue.submit([&](s::handler &cgh) {
         auto AccR = BufR.get_access<s::access::mode::write>(cgh);
         cgh.single_task<class maxF1F1>(
-            [=]() { AccR[0] = s::max(s::cl_float{0.5f}, s::cl_float{2.3f}); });
+            [=]() { AccR[0] = s::max(float{0.5f}, float{2.3f}); });
       });
     }
     assert(r == 2.3f);

SYCL/DeviceLib/built-ins/scalar_geometric.cpp

@@ -12,106 +12,104 @@ namespace s = sycl;
 int main() {
   // dot
   {
-    s::cl_float r{0};
+    float r{0};
     {
-      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::buffer<float, 1> BufR(&r, s::range<1>(1));
       s::queue myQueue;
       myQueue.submit([&](s::handler &cgh) {
         auto AccR = BufR.get_access<s::access::mode::write>(cgh);
         cgh.single_task<class dotF1F1>(
-            [=]() { AccR[0] = s::dot(s::cl_float{0.5}, s::cl_float{1.6}); });
+            [=]() { AccR[0] = s::dot(float{0.5}, float{1.6}); });
       });
     }
     assert(r == 0.8f);
   }
 
   // distance
   {
-    s::cl_float r{0};
+    float r{0};
     {
-      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::buffer<float, 1> BufR(&r, s::range<1>(1));
       s::queue myQueue;
       myQueue.submit([&](s::handler &cgh) {
         auto AccR = BufR.get_access<s::access::mode::write>(cgh);
-        cgh.single_task<class distanceF1>([=]() {
-          AccR[0] = s::distance(s::cl_float{1.f}, s::cl_float{3.f});
-        });
+        cgh.single_task<class distanceF1>(
+            [=]() { AccR[0] = s::distance(float{1.f}, float{3.f}); });
       });
     }
     assert(r == 2.f);
   }
 
   // length
   {
-    s::cl_float r{0};
+    float r{0};
     {
-      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::buffer<float, 1> BufR(&r, s::range<1>(1));
       s::queue myQueue;
       myQueue.submit([&](s::handler &cgh) {
         auto AccR = BufR.get_access<s::access::mode::write>(cgh);
         cgh.single_task<class lengthF1>(
-            [=]() { AccR[0] = s::length(s::cl_float{1.f}); });
+            [=]() { AccR[0] = s::length(float{1.f}); });
       });
     }
     assert(r == 1.f);
   }
 
   // normalize
   {
-    s::cl_float r{0};
+    float r{0};
     {
-      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::buffer<float, 1> BufR(&r, s::range<1>(1));
       s::queue myQueue;
       myQueue.submit([&](s::handler &cgh) {
         auto AccR = BufR.get_access<s::access::mode::write>(cgh);
         cgh.single_task<class normalizeF1>(
-            [=]() { AccR[0] = s::normalize(s::cl_float{2.f}); });
+            [=]() { AccR[0] = s::normalize(float{2.f}); });
       });
     }
     assert(r == 1.f);
   }
 
   // fast_distance
   {
-    s::cl_float r{0};
+    float r{0};
     {
-      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::buffer<float, 1> BufR(&r, s::range<1>(1));
       s::queue myQueue;
       myQueue.submit([&](s::handler &cgh) {
         auto AccR = BufR.get_access<s::access::mode::write>(cgh);
-        cgh.single_task<class fast_distanceF1>([=]() {
-          AccR[0] = s::fast_distance(s::cl_float{1.f}, s::cl_float{3.f});
-        });
+        cgh.single_task<class fast_distanceF1>(
+            [=]() { AccR[0] = s::fast_distance(float{1.f}, float{3.f}); });
       });
     }
     assert(r == 2.f);
   }
 
   // fast_length
   {
-    s::cl_float r{0};
+    float r{0};
     {
-      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::buffer<float, 1> BufR(&r, s::range<1>(1));
       s::queue myQueue;
       myQueue.submit([&](s::handler &cgh) {
         auto AccR = BufR.get_access<s::access::mode::write>(cgh);
         cgh.single_task<class fast_lengthF1>(
-            [=]() { AccR[0] = s::fast_length(s::cl_float{2.f}); });
+            [=]() { AccR[0] = s::fast_length(float{2.f}); });
       });
     }
     assert(r == 2.f);
   }
 
   // fast_normalize
   {
-    s::cl_float r{0};
+    float r{0};
     {
-      s::buffer<s::cl_float, 1> BufR(&r, s::range<1>(1));
+      s::buffer<float, 1> BufR(&r, s::range<1>(1));
       s::queue myQueue;
       myQueue.submit([&](s::handler &cgh) {
         auto AccR = BufR.get_access<s::access::mode::write>(cgh);
         cgh.single_task<class fast_normalizeF1>(
-            [=]() { AccR[0] = s::fast_normalize(s::cl_float{2.f}); });
+            [=]() { AccR[0] = s::fast_normalize(float{2.f}); });
       });
     }