First step to update to SYCL2020 (#523)

* Update namespace to sycl2020

Update included headers to sycl2020 standard

* Update device default selector to SYCL2020

* Remove SYCL_VERSION check

Removing all pragma that checks that sycl version used by compiler is
appropriate

* Update access::mode to access_mode
* Update ::target to new namespace and target

README.md

@@ -178,11 +178,11 @@ reference specification.
 
 All operations take as their first argument a reference to the SB_Handle, a
 `blas::SB_Handle` created with a `sycl::queue`. The last argument for all operators
-is a vector of dependencies of type `cl::sycl::event` (empty by default). The return value 
+is a vector of dependencies of type `sycl::event` (empty by default). The return value
 is usually an array of SYCL events (except for some operations that can return a scalar or
 a tuple). The containers for the vectors and matrices (and scalars written by
 the BLAS operations) can either be `raw usm pointers` or `iterator buffers` that can be 
-created with a call to `cl::sycl::malloc_device` or `make_sycl_iterator_buffer` respectively.
+created with a call to `sycl::malloc_device` or `make_sycl_iterator_buffer` respectively.
 
 The USM support in portBLAS is limited to `device allocated` memory only and we don't support
 `shared` or `host` allocations with USM. 

benchmark/cublas/blas1/asum.cpp

@@ -52,7 +52,7 @@ void run(benchmark::State& state, cublasHandle_t* cuda_handle_ptr, index_t size,
 
   // Create data
   std::vector<scalar_t> v1 = blas_benchmark::utils::random_data<scalar_t>(size);
-  // We need to guarantee that cl::sycl::half can hold the sum
+  // We need to guarantee that sycl::half can hold the sum
   // of x_v without overflow by making sum(x_v) to be 1.0
   std::transform(std::begin(v1), std::end(v1), std::begin(v1),
                  [=](scalar_t x) { return x / v1.size(); });

benchmark/cublas/blas1/dot.cpp

@@ -54,7 +54,7 @@ void run(benchmark::State& state, cublasHandle_t* cuda_handle_ptr, index_t size,
   std::vector<scalar_t> v1 = blas_benchmark::utils::random_data<scalar_t>(size);
   std::vector<scalar_t> v2 = blas_benchmark::utils::random_data<scalar_t>(size);
 
-  // Make sure cl::sycl::half can hold the result of the dot product
+  // Make sure sycl::half can hold the result of the dot product
   std::transform(std::begin(v1), std::end(v1), std::begin(v1),
                  [=](scalar_t x) { return x / v1.size(); });
 

benchmark/cublas/blas1/nrm2.cpp

@@ -54,7 +54,7 @@ void run(benchmark::State& state, cublasHandle_t* cuda_handle_ptr, index_t size,
   // Create data
   std::vector<scalar_t> v1 = blas_benchmark::utils::random_data<scalar_t>(size);
 
-  // We need to guarantee that cl::sycl::half can hold the norm of the vector
+  // We need to guarantee that sycl::half can hold the norm of the vector
   std::transform(std::begin(v1), std::end(v1), std::begin(v1),
                  [=](scalar_t x) { return x / v1.size(); });
 

benchmark/cublas/blas3/gemm.cpp

@@ -34,7 +34,7 @@ static inline void cublas_routine(args_t&&... args) {
     CUBLAS_CHECK(cublasSgemm(std::forward<args_t>(args)...));
   } else if constexpr (std::is_same_v<scalar_t, double>) {
     CUBLAS_CHECK(cublasDgemm(std::forward<args_t>(args)...));
-  } else if constexpr (std::is_same_v<scalar_t, cl::sycl::half>) {
+  } else if constexpr (std::is_same_v<scalar_t, sycl::half>) {
     CUBLAS_CHECK(cublasHgemm(std::forward<args_t>(args)...));
   }
   return;

benchmark/cublas/blas3/gemm_batched.cpp

@@ -34,7 +34,7 @@ static inline void cublas_routine(args_t&&... args) {
     CUBLAS_CHECK(cublasSgemmBatched(std::forward<args_t>(args)...));
   } else if constexpr (std::is_same_v<scalar_t, double>) {
     CUBLAS_CHECK(cublasDgemmBatched(std::forward<args_t>(args)...));
-  } else if constexpr (std::is_same_v<scalar_t, cl::sycl::half>) {
+  } else if constexpr (std::is_same_v<scalar_t, sycl::half>) {
     CUBLAS_CHECK(cublasHgemmBatched(std::forward<args_t>(args)...));
   }
   return;

benchmark/cublas/blas3/gemm_batched_strided.cpp

@@ -34,7 +34,7 @@ static inline void cublas_routine(args_t&&... args) {
     CUBLAS_CHECK(cublasSgemmStridedBatched(std::forward<args_t>(args)...));
   } else if constexpr (std::is_same_v<scalar_t, double>) {
     CUBLAS_CHECK(cublasDgemmStridedBatched(std::forward<args_t>(args)...));
-  } else if constexpr (std::is_same_v<scalar_t, cl::sycl::half>) {
+  } else if constexpr (std::is_same_v<scalar_t, sycl::half>) {
     CUBLAS_CHECK(cublasHgemmStridedBatched(std::forward<args_t>(args)...));
   }
   return;

benchmark/cublas/utils.hpp

@@ -287,7 +287,7 @@ struct CudaType {
 
 // When T is sycl::half, use cuda's __cuda as type.
 template <typename T>
-struct CudaType<T, std::enable_if_t<std::is_same_v<T, cl::sycl::half>>> {
+struct CudaType<T, std::enable_if_t<std::is_same_v<T, sycl::half>>> {
   using type = __half;
 };
 

benchmark/portblas/blas1/asum.cpp

@@ -45,7 +45,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   // Create data
   std::vector<scalar_t> v1 = blas_benchmark::utils::random_data<scalar_t>(size);
 
-  // We need to guarantee that cl::sycl::half can hold the sum
+  // We need to guarantee that sycl::half can hold the sum
   // of x_v without overflow by making sum(x_v) to be 1.0
   std::transform(std::begin(v1), std::end(v1), std::begin(v1),
                  [=](scalar_t x) { return x / v1.size(); });
@@ -82,7 +82,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _asum(sb_handle, size, inx, static_cast<index_t>(1), inr);
     sb_handle.wait(event);
     return event;

benchmark/portblas/blas1/axpy.cpp

@@ -42,8 +42,8 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   blas::SB_Handle& sb_handle = *sb_handle_ptr;
   auto q = sb_handle.get_queue();
 
-  if (std::is_same_v<scalar_t, cl::sycl::half> &&
-      !q.get_device().has(cl::sycl::aspect::fp16)) {
+  if (std::is_same_v<scalar_t, sycl::half> &&
+      !q.get_device().has(sycl::aspect::fp16)) {
     state.SkipWithError("Unsupported fp16 (half) on this device.");
   }
 
@@ -90,7 +90,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _axpy(sb_handle, size, alpha, inx, static_cast<index_t>(1),
                        iny, static_cast<index_t>(1));
     sb_handle.wait(event);

benchmark/portblas/blas1/copy.cpp

@@ -88,7 +88,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event =
         blas::_copy<blas::SB_Handle, index_t, decltype(x_gpu), decltype(y_gpu),
                     index_t>(sb_handle, size, x_gpu, incx, y_gpu, incy);

benchmark/portblas/blas1/dot.cpp

@@ -46,7 +46,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   std::vector<scalar_t> v1 = blas_benchmark::utils::random_data<scalar_t>(size);
   std::vector<scalar_t> v2 = blas_benchmark::utils::random_data<scalar_t>(size);
 
-  // Make sure cl::sycl::half can hold the result of the dot product
+  // Make sure sycl::half can hold the result of the dot product
   std::transform(std::begin(v1), std::end(v1), std::begin(v1),
                  [=](scalar_t x) { return x / v1.size(); });
 
@@ -85,7 +85,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _dot(sb_handle, size, inx, static_cast<index_t>(1), iny,
                       static_cast<index_t>(1), inr);
     sb_handle.wait(event);

benchmark/portblas/blas1/iamax.cpp

@@ -84,7 +84,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _iamax(sb_handle, size, inx, static_cast<index_t>(1), outI);
     sb_handle.wait(event);
     return event;

benchmark/portblas/blas1/iamin.cpp

@@ -83,7 +83,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _iamin(sb_handle, size, inx, static_cast<index_t>(1), outI);
     sb_handle.wait(event);
     return event;

benchmark/portblas/blas1/nrm2.cpp

@@ -45,7 +45,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   // Create data
   std::vector<scalar_t> v1 = blas_benchmark::utils::random_data<scalar_t>(size);
 
-  // We need to guarantee that cl::sycl::half can hold the norm of the vector
+  // We need to guarantee that sycl::half can hold the norm of the vector
   std::transform(std::begin(v1), std::end(v1), std::begin(v1),
                  [=](scalar_t x) { return x / v1.size(); });
 
@@ -81,7 +81,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _nrm2(sb_handle, size, inx, static_cast<index_t>(1), inr);
     sb_handle.wait(event);
     return event;

benchmark/portblas/blas1/rotg.cpp

@@ -124,7 +124,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
 #endif
 
   // Create a utility lambda describing the blas method that we want to run.
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _rotg(sb_handle, buf_a, buf_b, buf_c, buf_s);
     sb_handle.wait(event);
     return event;

benchmark/portblas/blas1/rotm.cpp

@@ -116,7 +116,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _rotm(sb_handle, size, gpu_x_v, static_cast<index_t>(1),
                        gpu_y_v, static_cast<index_t>(1), gpu_param);
     sb_handle.wait(event);

benchmark/portblas/blas1/rotmg.cpp

@@ -135,7 +135,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
 #endif
 
   // Create a utility lambda describing the blas method that we want to run.
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _rotmg(sb_handle, buf_d1, buf_d2, buf_x1, buf_y1, buf_param);
     sb_handle.wait(event);
     return event;

benchmark/portblas/blas1/scal.cpp

@@ -42,8 +42,8 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   blas::SB_Handle& sb_handle = *sb_handle_ptr;
   auto q = sb_handle.get_queue();
 
-  if (std::is_same_v<scalar_t, cl::sycl::half> &&
-      !q.get_device().has(cl::sycl::aspect::fp16)) {
+  if (std::is_same_v<scalar_t, sycl::half> &&
+      !q.get_device().has(sycl::aspect::fp16)) {
     state.SkipWithError("Unsupported fp16 (half) on this device.");
   }
 
@@ -84,7 +84,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _scal(sb_handle, size, alpha, in, static_cast<index_t>(1));
     sb_handle.wait(event);
     return event;

benchmark/portblas/blas1/sdsdot.cpp

@@ -84,7 +84,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t size,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _sdsdot(sb_handle, size, sb, inx, static_cast<index_t>(1), iny,
                          static_cast<index_t>(1), inr);
     sb_handle.wait(event);

benchmark/portblas/blas2/gbmv.cpp

@@ -104,7 +104,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, int ti,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _gbmv(sb_handle, *t_str, m, n, kl, ku, alpha, m_a_gpu, lda,
                        v_x_gpu, incX, beta, v_y_gpu, incY);
     sb_handle.wait(event);

benchmark/portblas/blas2/gemv.cpp

@@ -104,7 +104,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, int ti,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _gemv(sb_handle, *t_str, m, n, alpha, m_a_gpu, m, v_x_gpu,
                        incX, beta, v_y_gpu, incY);
     sb_handle.wait(event);

benchmark/portblas/blas2/ger.cpp

@@ -102,7 +102,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, index_t m,
 
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _ger(sb_handle, m, n, alpha, v_x_gpu, incX, v_y_gpu, incY,
                       m_a_gpu, lda);
     sb_handle.wait(event);

benchmark/portblas/blas2/sbmv.cpp

@@ -103,7 +103,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _sbmv(sb_handle, *uplo_str, n, k, alpha, m_a_gpu, lda, v_x_gpu,
                        incX, beta, v_y_gpu, incY);
     sb_handle.wait(event);

benchmark/portblas/blas2/spmv.cpp

@@ -101,7 +101,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _spmv(sb_handle, *uplo_str, n, alpha, m_a_gpu, v_x_gpu, incX,
                        beta, v_y_gpu, incY);
     sb_handle.wait(event);

benchmark/portblas/blas2/spr.cpp

@@ -92,7 +92,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, char uplo,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = blas::_spr<blas::SB_Handle, index_t, scalar_t,
                             decltype(v_x_gpu), index_t, decltype(m_a_gpu)>(
         sb_handle, uplo, size, alpha, v_x_gpu, incX, m_a_gpu);

benchmark/portblas/blas2/spr2.cpp

@@ -99,7 +99,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr, char uplo,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = blas::_spr2(sb_handle, uplo, n, alpha, v_x_gpu, incX, v_y_gpu,
                              incY, m_a_gpu);
     sb_handle.wait(event);

benchmark/portblas/blas2/symv.cpp

@@ -102,7 +102,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _symv(sb_handle, *uplo_str, n, alpha, m_a_gpu, lda, v_x_gpu,
                        incX, beta, v_y_gpu, incY);
     sb_handle.wait(event);

benchmark/portblas/blas2/syr.cpp

@@ -93,7 +93,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
 
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event =
         _syr(sb_handle, *uplo_str, n, alpha, v_x_gpu, incX, m_a_gpu, lda);
     sb_handle.wait(event);

benchmark/portblas/blas2/syr2.cpp

@@ -103,7 +103,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
 
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _syr2(sb_handle, *uplo_str, n, alpha, v_x_gpu, incX, v_y_gpu,
                        incY, m_a_gpu, lda);
     sb_handle.wait(event);

benchmark/portblas/blas2/tbmv.cpp

@@ -95,7 +95,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _tbmv(sb_handle, *uplo_str, *t_str, *diag_str, n, k, m_a_gpu,
                        lda, v_x_gpu, incX);
     sb_handle.wait(event);

benchmark/portblas/blas2/tbsv.cpp

@@ -106,7 +106,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _tbsv(sb_handle, *uplo_str, *t_str, *diag_str, n, k, m_a_gpu,
                        lda, v_x_gpu, incX);
     sb_handle.wait(event);

benchmark/portblas/blas2/tpmv.cpp

@@ -92,7 +92,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _tpmv(sb_handle, *uplo_str, *t_str, *diag_str, n, m_a_gpu,
                        v_x_gpu, incX);
     sb_handle.wait(event);

benchmark/portblas/blas2/tpsv.cpp

@@ -106,7 +106,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _tpsv(sb_handle, *uplo_str, *t_str, *diag_str, n, m_a_gpu,
                        v_x_gpu, incX);
     sb_handle.wait(event);

benchmark/portblas/blas2/trmv.cpp

@@ -96,7 +96,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _trmv(sb_handle, *uplo_str, *t_str, *diag_str, n, m_a_gpu, lda,
                        v_x_gpu, incX);
     sb_handle.wait(event);

benchmark/portblas/blas2/trsv.cpp

@@ -104,7 +104,7 @@ void run(benchmark::State& state, blas::SB_Handle* sb_handle_ptr,
   };
 #endif
 
-  auto blas_method_def = [&]() -> std::vector<cl::sycl::event> {
+  auto blas_method_def = [&]() -> std::vector<sycl::event> {
     auto event = _trsv(sb_handle, *uplo_str, *t_str, *diag_str, n, m_a_gpu, lda,
                        v_x_gpu, incX);
     sb_handle.wait(event);