[BLAS][generic] Fix compilation with AdaptiveCpp

The generic BLAS backend currently offers limited support for
AdaptiveCpp, where:
* complex data type is not supported
* USM API is not supported

Add the required protections to make the generic BLAS backend
compile and run correctly in the capacity it offers with AdaptiveCpp.
That is, make the buffer USM without complex data work fine. Throw
the unimplemented exception for the unsupported features.

Note: fixes on the backend side are also required to actually compile,
see uxlfoundation/generic-sycl-components#7

Author: rafbiels

src/blas/backends/generic/generic_common.hpp

@@ -40,9 +40,11 @@ using handle_t = ::blas::SB_Handle;
 template <typename ElemT>
 using buffer_iterator_t = ::blas::BufferIterator<ElemT>;
 
+#ifdef BLAS_ENABLE_COMPLEX
 // sycl complex data type (experimental)
 template <typename ElemT>
 using sycl_complex_t = sycl::ext::oneapi::experimental::complex<ElemT>;
+#endif
 
 /** A trait for obtaining equivalent onemath_sycl_blas API types from oneMath API
  *  types.
@@ -68,8 +70,10 @@ DEF_GENERIC_BLAS_TYPE(oneapi::math::transpose, char)
 DEF_GENERIC_BLAS_TYPE(oneapi::math::uplo, char)
 DEF_GENERIC_BLAS_TYPE(oneapi::math::side, char)
 DEF_GENERIC_BLAS_TYPE(oneapi::math::diag, char)
+#ifdef BLAS_ENABLE_COMPLEX
 DEF_GENERIC_BLAS_TYPE(std::complex<float>, sycl_complex_t<float>)
 DEF_GENERIC_BLAS_TYPE(std::complex<double>, sycl_complex_t<double>)
+#endif
 // Passthrough of onemath_sycl_blas arg types for more complex wrapping.
 DEF_GENERIC_BLAS_TYPE(::blas::gemm_batch_type_t, ::blas::gemm_batch_type_t)
 
@@ -85,6 +89,7 @@ struct generic_type<ElemT*> {
     using type = ElemT*;
 };
 
+#ifdef BLAS_ENABLE_COMPLEX
 // USM Complex
 template <typename ElemT>
 struct generic_type<std::complex<ElemT>*> {
@@ -95,6 +100,7 @@ template <typename ElemT>
 struct generic_type<const std::complex<ElemT>*> {
     using type = const sycl_complex_t<ElemT>*;
 };
+#endif
 
 template <>
 struct generic_type<std::vector<sycl::event>> {
@@ -210,6 +216,10 @@ struct throw_if_unsupported_by_device {
         throw unimplemented("blas", "onemath_sycl_blas function");                              \
     }
 
+#ifndef SB_ENABLE_USM
+#define CALL_GENERIC_BLAS_USM_FN(genericFunc, ...) \
+    throw unimplemented("blas", "onemath_sycl_blas USM API", "- unsupported compiler");
+#else
 #define CALL_GENERIC_BLAS_USM_FN(genericFunc, ...)                                \
     if constexpr (is_column_major()) {                                            \
         detail::throw_if_unsupported_by_device<double, sycl::aspect::fp64>{}(     \
@@ -230,6 +240,7 @@ struct throw_if_unsupported_by_device {
     else {                                                                        \
         throw unimplemented("blas", "onemath_sycl_blas function");                \
     }
+#endif
 
 } // namespace generic
 } // namespace blas

src/blas/backends/generic/generic_level3.cxx

@@ -32,6 +32,9 @@ void gemm(sycl::queue& queue, oneapi::math::transpose transa, oneapi::math::tran
           sycl::buffer<std::complex<real_t>, 1>& a, std::int64_t lda,
           sycl::buffer<std::complex<real_t>, 1>& b, std::int64_t ldb, std::complex<real_t> beta,
           sycl::buffer<std::complex<real_t>, 1>& c, std::int64_t ldc) {
+    #ifndef BLAS_ENABLE_COMPLEX
+    throw unimplemented("blas", "onemath_sycl_blas gemm with complex data type", "- unsupported compiler");
+    #else
     using sycl_complex_real_t = sycl::ext::oneapi::experimental::complex<real_t>;
     if (transa == oneapi::math::transpose::conjtrans ||
         transb == oneapi::math::transpose::conjtrans) {
@@ -62,6 +65,7 @@ void gemm(sycl::queue& queue, oneapi::math::transpose transa, oneapi::math::tran
     sycl::accessor<std::complex<real_t>, 1, sycl::access::mode::write> out_acc(c);
     sycl::accessor<sycl_complex_real_t, 1, sycl::access::mode::read> out_pb_acc(c_pb);
     queue.copy(out_pb_acc, out_acc);
+    #endif
 }
 
 void symm(sycl::queue& queue, oneapi::math::side left_right, oneapi::math::uplo upper_lower,