diff --git a/backends/include/dppl_sycl_platform_interface.h b/backends/include/dppl_sycl_platform_interface.h index 22bebd9cbc..b3df1b5c56 100644 --- a/backends/include/dppl_sycl_platform_interface.h +++ b/backends/include/dppl_sycl_platform_interface.h @@ -34,29 +34,30 @@ DPPL_C_EXTERN_C_BEGIN /*! - * @brief Returns the number of sycl::platform available on the system. + * @brief Returns the number of non-host type sycl::platform available on the + * system. * * @return The number of available sycl::platforms. */ DPPL_API -size_t DPPLPlatform_GetNumPlatforms (); +size_t DPPLPlatform_GetNumNonHostPlatforms (); /*! - * @brief Returns the number of unique sycl backends on the system not counting - * the host backend. + * @brief Returns the number of unique non-host sycl backends on the system. * * @return The number of unique sycl backends. */ DPPL_API -size_t DPPLPlatform_GetNumBackends (); +size_t DPPLPlatform_GetNumNonHostBackends (); /*! - * @brief Returns an array of the unique DPPLSyclBackendType values on the system. + * @brief Returns an array of the unique non-host DPPLSyclBackendType values on + * the system. * * @return An array of DPPLSyclBackendType enum values. */ DPPL_API -__dppl_give DPPLSyclBackendType* DPPLPlatform_GetListOfBackends (); +__dppl_give DPPLSyclBackendType* DPPLPlatform_GetListOfNonHostBackends (); /*! * @brief Frees an array of DPPLSyclBackendType enum values. diff --git a/backends/include/dppl_sycl_queue_manager.h b/backends/include/dppl_sycl_queue_manager.h index d02040998c..73822146d4 100644 --- a/backends/include/dppl_sycl_queue_manager.h +++ b/backends/include/dppl_sycl_queue_manager.h @@ -78,7 +78,6 @@ DPPLQueueMgr_GetQueue (DPPLSyclBackendType BETy, DPPL_API size_t DPPLQueueMgr_GetNumActivatedQueues (); - /*! * @brief Get the number of available queues for given backend and device type * combination. diff --git a/backends/source/dppl_sycl_platform_interface.cpp b/backends/source/dppl_sycl_platform_interface.cpp index e03659cb90..2aa0af7ed4 100644 --- a/backends/source/dppl_sycl_platform_interface.cpp +++ b/backends/source/dppl_sycl_platform_interface.cpp @@ -37,7 +37,7 @@ using namespace cl::sycl; namespace { std::set -get_set_of_backends () +get_set_of_non_hostbackends () { std::set be_set; for (auto p : platform::get_platforms()) { @@ -47,7 +47,6 @@ get_set_of_backends () switch (be) { case backend::host: - be_set.insert(DPPLSyclBackendType::DPPL_HOST); break; case backend::cuda: be_set.insert(DPPLSyclBackendType::DPPL_CUDA); @@ -154,19 +153,25 @@ void DPPLPlatform_DumpInfo () /*! * Returns the number of sycl::platform on the system. */ -size_t DPPLPlatform_GetNumPlatforms () +size_t DPPLPlatform_GetNumNonHostPlatforms () { - return platform::get_platforms().size(); + auto nNonHostPlatforms = 0ul; + for (auto &p : platform::get_platforms()) { + if (p.is_host()) + continue; + ++nNonHostPlatforms; + } + return nNonHostPlatforms; } -size_t DPPLPlatform_GetNumBackends () +size_t DPPLPlatform_GetNumNonHostBackends () { - return get_set_of_backends().size(); + return get_set_of_non_hostbackends().size(); } -__dppl_give DPPLSyclBackendType *DPPLPlatform_GetListOfBackends () +__dppl_give DPPLSyclBackendType *DPPLPlatform_GetListOfNonHostBackends () { - auto be_set = get_set_of_backends(); + auto be_set = get_set_of_non_hostbackends(); if (be_set.empty()) return nullptr; diff --git a/backends/source/dppl_sycl_queue_interface.cpp b/backends/source/dppl_sycl_queue_interface.cpp index b4c8379e88..0231df8cf8 100644 --- a/backends/source/dppl_sycl_queue_interface.cpp +++ b/backends/source/dppl_sycl_queue_interface.cpp @@ -27,6 +27,8 @@ #include "dppl_sycl_queue_interface.h" #include "dppl_sycl_context_interface.h" #include "Support/CBindingWrapping.h" +#include +#include #include /* SYCL headers */ @@ -134,8 +136,15 @@ bool DPPLQueue_AreEq (__dppl_keep const DPPLSyclQueueRef QRef1, DPPLSyclBackendType DPPLQueue_GetBackend (__dppl_keep DPPLSyclQueueRef QRef) { auto Q = unwrap(QRef); - auto C = Q->get_context(); - return DPPLContext_GetBackend(wrap(&C)); + try { + auto C = Q->get_context(); + return DPPLContext_GetBackend(wrap(&C)); + } + catch (runtime_error &re) { + std::cerr << re.what() << '\n'; + // store error message + return DPPL_UNKNOWN_BACKEND; + } } __dppl_give DPPLSyclDeviceRef diff --git a/backends/source/dppl_sycl_queue_manager.cpp b/backends/source/dppl_sycl_queue_manager.cpp index e6f64457fa..cd9510e197 100644 --- a/backends/source/dppl_sycl_queue_manager.cpp +++ b/backends/source/dppl_sycl_queue_manager.cpp @@ -25,7 +25,6 @@ //===----------------------------------------------------------------------===// #include "dppl_sycl_queue_manager.h" #include "Support/CBindingWrapping.h" -#include #include #include @@ -54,7 +53,8 @@ class QMgrHelper public: using QVec = vector_class; - static QVec* init_queues (backend BE, info::device_type DTy) { + static QVec* init_queues (backend BE, info::device_type DTy) + { QVec *queues = new QVec(); auto Platforms = platform::get_platforms(); for (auto &p : Platforms) { @@ -88,6 +88,42 @@ class QMgrHelper return queues; } + static QVec* init_active_queues () + { + QVec *active_queues; + try { + auto def_device = std::move(default_selector().select_device()); + auto BE = def_device.get_platform().get_backend(); + auto DevTy = def_device.get_info(); + + // \todo : We need to have a better way to match the default device + // to what SYCL returns based on the same scoring logic. Just + // storing the first device is not correct when we will have + // multiple devices of same type. + if(BE == backend::opencl && + DevTy == info::device_type::cpu) { + active_queues = new QVec({get_opencl_cpu_queues()[0]}); + } + else if(BE == backend::opencl && + DevTy == info::device_type::gpu) { + active_queues = new QVec({get_opencl_gpu_queues()[0]}); + } + else if(BE == backend::level_zero && + DevTy == info::device_type::gpu) { + active_queues = new QVec({get_level0_gpu_queues()[0]}); + } + else { + active_queues = new QVec(); + } + } + catch (runtime_error &re) { + // \todo Handle the error + active_queues = new QVec(); + } + + return active_queues; + } + static QVec& get_opencl_cpu_queues () { static QVec* queues = init_queues(backend::opencl, @@ -111,8 +147,7 @@ class QMgrHelper static QVec& get_active_queues () { - thread_local static QVec* active_queues = - new QVec({default_selector()}); + thread_local static QVec *active_queues = init_active_queues(); return *active_queues; } @@ -149,7 +184,7 @@ class QMgrHelper */ DPPLSyclQueueRef QMgrHelper::getCurrentQueue () { - auto activated_q = get_active_queues(); + auto &activated_q = get_active_queues(); if(activated_q.empty()) { // \todo handle error std::cerr << "No currently active queues.\n"; @@ -225,7 +260,7 @@ QMgrHelper::getQueue (DPPLSyclBackendType BETy, */ bool QMgrHelper::isCurrentQueue (__dppl_keep const DPPLSyclQueueRef QRef) { - auto activated_q = get_active_queues(); + auto &activated_q = get_active_queues(); if(activated_q.empty()) { // \todo handle error std::cerr << "No currently active queues.\n"; diff --git a/backends/tests/test_sycl_platform_interface.cpp b/backends/tests/test_sycl_platform_interface.cpp index 87d2169606..fed815e9bf 100644 --- a/backends/tests/test_sycl_platform_interface.cpp +++ b/backends/tests/test_sycl_platform_interface.cpp @@ -31,26 +31,31 @@ struct TestDPPLSyclPlatformInterface : public ::testing::Test TEST_F (TestDPPLSyclPlatformInterface, CheckGetNumPlatforms) { - auto nplatforms = DPPLPlatform_GetNumPlatforms(); + auto nplatforms = DPPLPlatform_GetNumNonHostPlatforms(); EXPECT_GE(nplatforms, 0); } TEST_F (TestDPPLSyclPlatformInterface, GetNumBackends) { - auto nbackends = DPPLPlatform_GetNumBackends(); + auto nbackends = DPPLPlatform_GetNumNonHostBackends(); EXPECT_GE(nbackends, 0); } TEST_F (TestDPPLSyclPlatformInterface, GetListOfBackends) { - auto nbackends = DPPLPlatform_GetNumBackends(); - auto backends = DPPLPlatform_GetListOfBackends(); - EXPECT_TRUE(backends != nullptr); + auto nbackends = DPPLPlatform_GetNumNonHostBackends(); + + if(!nbackends) + GTEST_SKIP_("No non host backends available"); + + auto backends = DPPLPlatform_GetListOfNonHostBackends(); + EXPECT_TRUE(backends != nullptr); for(auto i = 0ul; i < nbackends; ++i) { EXPECT_TRUE( backends[i] == DPPLSyclBackendType::DPPL_CUDA || backends[i] == DPPLSyclBackendType::DPPL_OPENCL || - backends[i] == DPPLSyclBackendType::DPPL_LEVEL_ZERO); + backends[i] == DPPLSyclBackendType::DPPL_LEVEL_ZERO + ); } DPPLPlatform_DeleteListOfBackends(backends); } diff --git a/backends/tests/test_sycl_queue_interface.cpp b/backends/tests/test_sycl_queue_interface.cpp index a2946d5dda..2d68bdcdec 100644 --- a/backends/tests/test_sycl_queue_interface.cpp +++ b/backends/tests/test_sycl_queue_interface.cpp @@ -31,32 +31,48 @@ #include "dppl_sycl_queue_interface.h" #include "dppl_sycl_queue_manager.h" #include "dppl_sycl_usm_interface.h" - #include "Support/CBindingWrapping.h" - +#include #include +using namespace cl::sycl; + namespace { - constexpr size_t SIZE = 1024; +constexpr size_t SIZE = 1024; - DEFINE_SIMPLE_CONVERSION_FUNCTIONS(void, DPPLSyclUSMRef); +DEFINE_SIMPLE_CONVERSION_FUNCTIONS(void, DPPLSyclUSMRef); - void add_kernel_checker (const float *a, const float *b, const float *c) - { - // Validate the data - for(auto i = 0ul; i < SIZE; ++i) { - EXPECT_EQ(c[i], a[i] + b[i]); - } +void add_kernel_checker (const float *a, const float *b, const float *c) +{ + // Validate the data + for(auto i = 0ul; i < SIZE; ++i) { + EXPECT_EQ(c[i], a[i] + b[i]); } +} + +void axpy_kernel_checker (const float *a, const float *b, const float *c, + float d) +{ + for(auto i = 0ul; i < SIZE; ++i) { + EXPECT_EQ(c[i], a[i] + d*b[i]); + } +} - void axpy_kernel_checker (const float *a, const float *b, const float *c, - float d) - { - for(auto i = 0ul; i < SIZE; ++i) { - EXPECT_EQ(c[i], a[i] + d*b[i]); +bool has_devices () +{ + bool ret = false; + for (auto &p : platform::get_platforms()) { + if (p.is_host()) + continue; + if(!p.get_devices().empty()) { + ret = true; + break; } } + return ret; +} + } struct TestDPPLSyclQueueInterface : public ::testing::Test @@ -89,17 +105,17 @@ struct TestDPPLSyclQueueInterface : public ::testing::Test TEST_F (TestDPPLSyclQueueInterface, CheckAreEq) { - auto Q1 = DPPLQueueMgr_GetCurrentQueue(); - auto Q2 = DPPLQueueMgr_GetCurrentQueue(); - EXPECT_TRUE(DPPLQueue_AreEq(Q1, Q2)); + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); auto nOclGPU = DPPLQueueMgr_GetNumQueues(DPPLSyclBackendType::DPPL_OPENCL, DPPLSyclDeviceType::DPPL_GPU); - auto nOclCPU = DPPLQueueMgr_GetNumQueues(DPPLSyclBackendType::DPPL_OPENCL, - DPPLSyclDeviceType::DPPL_CPU); - { if(!nOclGPU) - GTEST_SKIP_("No OpenCL GPUs available.\n"); + GTEST_SKIP_("Skipping: No OpenCL GPUs available.\n"); + + auto Q1 = DPPLQueueMgr_GetCurrentQueue(); + auto Q2 = DPPLQueueMgr_GetCurrentQueue(); + EXPECT_TRUE(DPPLQueue_AreEq(Q1, Q2)); auto Def_Q = DPPLQueueMgr_SetAsDefaultQueue( DPPLSyclBackendType::DPPL_OPENCL, @@ -124,9 +140,17 @@ TEST_F (TestDPPLSyclQueueInterface, CheckAreEq) DPPLQueue_Delete(OclGPU_Q1); DPPLQueueMgr_PopQueue(); DPPLQueueMgr_PopQueue(); - } +} + +TEST_F (TestDPPLSyclQueueInterface, CheckAreEq2) +{ + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); - { + auto nOclGPU = DPPLQueueMgr_GetNumQueues(DPPLSyclBackendType::DPPL_OPENCL, + DPPLSyclDeviceType::DPPL_GPU); + auto nOclCPU = DPPLQueueMgr_GetNumQueues(DPPLSyclBackendType::DPPL_OPENCL, + DPPLSyclDeviceType::DPPL_CPU); if(!nOclGPU || !nOclCPU) GTEST_SKIP_("OpenCL GPUs and CPU not available.\n"); auto GPU_Q = DPPLQueueMgr_PushQueue( @@ -142,12 +166,13 @@ TEST_F (TestDPPLSyclQueueInterface, CheckAreEq) EXPECT_FALSE(DPPLQueue_AreEq(GPU_Q, CPU_Q)); DPPLQueueMgr_PopQueue(); DPPLQueueMgr_PopQueue(); - } - } TEST_F (TestDPPLSyclQueueInterface, CheckGetBackend) { + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); + auto Q1 = DPPLQueueMgr_GetCurrentQueue(); auto BE = DPPLQueue_GetBackend(Q1); EXPECT_TRUE((BE == DPPL_OPENCL) || @@ -178,6 +203,9 @@ TEST_F (TestDPPLSyclQueueInterface, CheckGetBackend) TEST_F (TestDPPLSyclQueueInterface, CheckGetContext) { + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); + auto Q1 = DPPLQueueMgr_GetCurrentQueue(); auto Ctx = DPPLQueue_GetContext(Q1); ASSERT_TRUE(Ctx != nullptr); @@ -212,6 +240,9 @@ TEST_F (TestDPPLSyclQueueInterface, CheckGetContext) TEST_F (TestDPPLSyclQueueInterface, CheckGetDevice) { + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); + auto Q1 = DPPLQueueMgr_GetCurrentQueue(); auto D = DPPLQueue_GetDevice(Q1); ASSERT_TRUE(D != nullptr); @@ -249,10 +280,13 @@ TEST_F (TestDPPLSyclQueueInterface, CheckGetDevice) TEST_F (TestDPPLSyclQueueInterface, CheckSubmit) { + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); + auto nOpenCLGpuQ = DPPLQueueMgr_GetNumQueues(DPPL_OPENCL, DPPL_GPU); if(!nOpenCLGpuQ) - GTEST_SKIP_("Skipping as no OpenCL GPU device found.\n"); + GTEST_SKIP_("Skipping: No OpenCL GPU device.\n"); auto Queue = DPPLQueueMgr_GetQueue(DPPL_OPENCL, DPPL_GPU, 0); auto CtxRef = DPPLQueue_GetContext(Queue); diff --git a/backends/tests/test_sycl_queue_manager.cpp b/backends/tests/test_sycl_queue_manager.cpp index 510aee93e6..55f8cb725d 100644 --- a/backends/tests/test_sycl_queue_manager.cpp +++ b/backends/tests/test_sycl_queue_manager.cpp @@ -37,26 +37,41 @@ using namespace cl::sycl; namespace { - void foo (size_t & num) - { - auto q1 = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_CPU, 0); - auto q2 = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_GPU, 0); - // Capture the number of active queues in first - num = DPPLQueueMgr_GetNumActivatedQueues(); - DPPLQueueMgr_PopQueue(); - DPPLQueueMgr_PopQueue(); - DPPLQueue_Delete(q1); - DPPLQueue_Delete(q2); - } +void foo (size_t & num) +{ + auto q1 = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_CPU, 0); + auto q2 = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_GPU, 0); + // Capture the number of active queues in first + num = DPPLQueueMgr_GetNumActivatedQueues(); + DPPLQueueMgr_PopQueue(); + DPPLQueueMgr_PopQueue(); + DPPLQueue_Delete(q1); + DPPLQueue_Delete(q2); +} - void bar (size_t & num) - { - auto q1 = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_GPU, 0); - // Capture the number of active queues in second - num = DPPLQueueMgr_GetNumActivatedQueues(); - DPPLQueueMgr_PopQueue(); - DPPLQueue_Delete(q1); +void bar (size_t & num) +{ + auto q1 = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_GPU, 0); + // Capture the number of active queues in second + num = DPPLQueueMgr_GetNumActivatedQueues(); + DPPLQueueMgr_PopQueue(); + DPPLQueue_Delete(q1); +} + +bool has_devices () +{ + bool ret = false; + for (auto &p : platform::get_platforms()) { + if (p.is_host()) + continue; + if(!p.get_devices().empty()) { + ret = true; + break; + } } + return ret; +} + } struct TestDPPLSyclQueueManager : public ::testing::Test @@ -65,6 +80,9 @@ struct TestDPPLSyclQueueManager : public ::testing::Test TEST_F (TestDPPLSyclQueueManager, CheckDPPLGetCurrentQueue) { + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); + DPPLSyclQueueRef q; ASSERT_NO_THROW(q = DPPLQueueMgr_GetCurrentQueue()); ASSERT_TRUE(q != nullptr); @@ -73,9 +91,12 @@ TEST_F (TestDPPLSyclQueueManager, CheckDPPLGetCurrentQueue) TEST_F (TestDPPLSyclQueueManager, CheckDPPLGetOpenCLCpuQ) { + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); + auto nOpenCLCpuQ = DPPLQueueMgr_GetNumQueues(DPPL_OPENCL, DPPL_CPU); if(!nOpenCLCpuQ) - GTEST_SKIP_("Skipping as no OpenCL CPU device found."); + GTEST_SKIP_("Skipping: No OpenCL CPU device found."); auto q = DPPLQueueMgr_GetQueue(DPPL_OPENCL, DPPL_CPU, 0); EXPECT_TRUE(q != nullptr); @@ -94,9 +115,12 @@ TEST_F (TestDPPLSyclQueueManager, CheckDPPLGetOpenCLCpuQ) TEST_F (TestDPPLSyclQueueManager, CheckDPPLGetOpenCLGpuQ) { + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); + auto nOpenCLGpuQ = DPPLQueueMgr_GetNumQueues(DPPL_OPENCL, DPPL_GPU); if(!nOpenCLGpuQ) - GTEST_SKIP_("Skipping as no OpenCL GPU device found.\n"); + GTEST_SKIP_("Skipping: No OpenCL GPU device found.\n"); auto q = DPPLQueueMgr_GetQueue(DPPL_OPENCL, DPPL_GPU, 0); EXPECT_TRUE(q != nullptr); @@ -115,9 +139,12 @@ TEST_F (TestDPPLSyclQueueManager, CheckDPPLGetOpenCLGpuQ) TEST_F (TestDPPLSyclQueueManager, CheckDPPLGetLevel0GpuQ) { + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); + auto nL0GpuQ = DPPLQueueMgr_GetNumQueues(DPPL_LEVEL_ZERO, DPPL_GPU); if(!nL0GpuQ) - GTEST_SKIP_("Skipping as no OpenCL GPU device found.\n"); + GTEST_SKIP_("Skipping: No OpenCL GPU device found.\n"); auto q = DPPLQueueMgr_GetQueue(DPPL_LEVEL_ZERO, DPPL_GPU, 0); EXPECT_TRUE(q != nullptr); @@ -136,6 +163,9 @@ TEST_F (TestDPPLSyclQueueManager, CheckDPPLGetLevel0GpuQ) TEST_F (TestDPPLSyclQueueManager, CheckGetNumActivatedQueues) { + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); + size_t num0, num1, num2, num4; auto nOpenCLCpuQ = DPPLQueueMgr_GetNumQueues(DPPL_OPENCL, DPPL_CPU); @@ -172,6 +202,8 @@ TEST_F (TestDPPLSyclQueueManager, CheckGetNumActivatedQueues) TEST_F (TestDPPLSyclQueueManager, CheckDPPLDumpDeviceInfo) { + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); auto q = DPPLQueueMgr_GetCurrentQueue(); EXPECT_NO_FATAL_FAILURE(DPPLDevice_DumpInfo(DPPLQueue_GetDevice(q))); EXPECT_NO_FATAL_FAILURE(DPPLQueue_Delete(q)); @@ -179,20 +211,39 @@ TEST_F (TestDPPLSyclQueueManager, CheckDPPLDumpDeviceInfo) TEST_F (TestDPPLSyclQueueManager, CheckIsCurrentQueue) { + if(!has_devices()) + GTEST_SKIP_("Skipping: No Sycl devices.\n"); if(!DPPLQueueMgr_GetNumQueues(DPPL_OPENCL, DPPL_GPU)) - GTEST_SKIP_("No OpenCL GPU.\n"); + GTEST_SKIP_("Skipping: No OpenCL GPU.\n"); auto Q0 = DPPLQueueMgr_GetCurrentQueue(); EXPECT_TRUE(DPPLQueueMgr_IsCurrentQueue(Q0)); - auto Q = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_GPU, 0); - EXPECT_TRUE(DPPLQueueMgr_IsCurrentQueue(Q)); - EXPECT_FALSE(DPPLQueueMgr_IsCurrentQueue(Q0)); - DPPLQueue_Delete(Q); + auto Q1 = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_GPU, 0); + EXPECT_TRUE(DPPLQueueMgr_IsCurrentQueue(Q1)); + DPPLQueue_Delete(Q1); DPPLQueueMgr_PopQueue(); EXPECT_TRUE(DPPLQueueMgr_IsCurrentQueue(Q0)); DPPLQueue_Delete(Q0); } +TEST_F (TestDPPLSyclQueueManager, CheckIsCurrentQueue2) +{ + if(!DPPLQueueMgr_GetNumQueues(DPPL_OPENCL, DPPL_CPU) || + !DPPLQueueMgr_GetNumQueues(DPPL_OPENCL, DPPL_GPU)) + GTEST_SKIP_("Skipping: No OpenCL GPU and OpenCL CPU.\n"); + + auto Q1 = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_GPU, 0); + EXPECT_TRUE(DPPLQueueMgr_IsCurrentQueue(Q1)); + auto Q2 = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_CPU, 0); + EXPECT_TRUE(DPPLQueueMgr_IsCurrentQueue(Q2)); + EXPECT_FALSE(DPPLQueueMgr_IsCurrentQueue(Q1)); + DPPLQueue_Delete(Q2); + DPPLQueueMgr_PopQueue(); + EXPECT_TRUE(DPPLQueueMgr_IsCurrentQueue(Q1)); + DPPLQueue_Delete(Q1); + DPPLQueueMgr_PopQueue(); +} + int main (int argc, char** argv) { diff --git a/dpctl/backend.pxd b/dpctl/backend.pxd index c36a9ffed4..3fa9dff8a0 100644 --- a/dpctl/backend.pxd +++ b/dpctl/backend.pxd @@ -115,10 +115,10 @@ cdef extern from "dppl_sycl_kernel_interface.h": cdef extern from "dppl_sycl_platform_interface.h": - cdef size_t DPPLPlatform_GetNumPlatforms () + cdef size_t DPPLPlatform_GetNumNonHostPlatforms () cdef void DPPLPlatform_DumpInfo () - cdef size_t DPPLPlatform_GetNumBackends () - cdef DPPLSyclBackendType *DPPLPlatform_GetListOfBackends () + cdef size_t DPPLPlatform_GetNumNonHostBackends () + cdef DPPLSyclBackendType *DPPLPlatform_GetListOfNonHostBackends () cdef void DPPLPlatform_DeleteListOfBackends (DPPLSyclBackendType * BEs) diff --git a/dpctl/sycl_core.pyx b/dpctl/sycl_core.pyx index 19a376a8ec..849b840f12 100644 --- a/dpctl/sycl_core.pyx +++ b/dpctl/sycl_core.pyx @@ -305,6 +305,8 @@ cdef class SyclQueue: @staticmethod cdef SyclQueue _create (DPPLSyclQueueRef qref): + if qref is NULL: + raise SyclQueueCreationError("Queue creation failed.") cdef SyclQueue ret = SyclQueue.__new__(SyclQueue) ret._context = SyclContext._create(DPPLQueue_GetContext(qref)) ret._device = SyclDevice._create(DPPLQueue_GetDevice(qref)) @@ -586,15 +588,6 @@ cdef class _SyclRTManager: device_type.gpu : _device_type._GPU, } - cdef _raise_queue_creation_error (self, str be, str dev, int devid, fname): - e = SyclQueueCreationError( - "Queue creation failed for :", be, dev, devid - ) - e.fname = fname - e.code = -1 - raise e - - def _set_as_current_queue (self, backend_ty, device_ty, device_id): cdef DPPLSyclQueueRef queue_ref @@ -603,11 +596,6 @@ cdef class _SyclRTManager: try : devTy = self._device_str_ty_dict[device_ty] queue_ref = DPPLQueueMgr_PushQueue(beTy, devTy, device_id) - if queue_ref is NULL: - self._raise_queue_creation_error( - backend_ty, device_ty, device_id, - "DPPLQueueMgr_PushQueue" - ) return SyclQueue._create(queue_ref) except KeyError: raise UnsupportedDeviceError("Device can only be gpu or cpu") @@ -649,9 +637,9 @@ cdef class _SyclRTManager: return DPPLQueueMgr_GetNumActivatedQueues() def get_num_platforms (self): - ''' Returns the number of available SYCL/OpenCL platforms. + ''' Returns the number of available non-host SYCL platforms. ''' - return DPPLPlatform_GetNumPlatforms() + return DPPLPlatform_GetNumNonHostPlatforms() def get_num_queues (self, backend_ty, device_ty): cdef size_t num = 0 @@ -703,7 +691,7 @@ cdef class _SyclRTManager: return False def has_sycl_platforms (self): - cdef size_t num_platforms = DPPLPlatform_GetNumPlatforms() + cdef size_t num_platforms = DPPLPlatform_GetNumNonHostPlatforms() if num_platforms: return True else: diff --git a/dpctl/tests/test_dump_functions.py b/dpctl/tests/test_dump_functions.py index 66ec0acc5b..29ebe31b7a 100644 --- a/dpctl/tests/test_dump_functions.py +++ b/dpctl/tests/test_dump_functions.py @@ -35,6 +35,8 @@ def test_dpctl_dump (self): except Exception: self.fail("Encountered an exception inside dump().") + @unittest.skipUnless(dpctl.has_sycl_platforms(), + "No SYCL devices except the default host device.") def test_dpctl_dump_device_info (self): q = dpctl.get_current_queue() try: @@ -42,11 +44,11 @@ def test_dpctl_dump_device_info (self): except Exception: self.fail("Encountered an exception inside dump_device_info().") - def test_dpctl_ocldrv_dump (self): - try: - dpctl.ocldrv.runtime.dump() - except Exception: - self.fail("Encountered an exception inside dump_device_info().") + # def test_dpctl_ocldrv_dump (self): + # try: + # dpctl.ocldrv.runtime.dump() + # except Exception: + # self.fail("Encountered an exception inside dump_device_info().") if __name__ == '__main__': unittest.main() diff --git a/dpctl/tests/test_sycl_queue_memcpy.py b/dpctl/tests/test_sycl_queue_memcpy.py index 6cb95ea63e..71abf6fb98 100644 --- a/dpctl/tests/test_sycl_queue_memcpy.py +++ b/dpctl/tests/test_sycl_queue_memcpy.py @@ -26,7 +26,6 @@ import unittest - class TestQueueMemcpy (unittest.TestCase): def _create_memory (self): @@ -35,6 +34,8 @@ def _create_memory (self): mobj = dpctl._memory.MemoryUSMShared(nbytes, queue) return mobj + @unittest.skipUnless(dpctl.has_sycl_platforms(), + "No SYCL devices except the default host device.") def test_memcpy_copy_usm_to_usm (self): mobj1 = self._create_memory() mobj2 = self._create_memory() @@ -49,6 +50,8 @@ def test_memcpy_copy_usm_to_usm (self): self.assertEqual(mv2[:3], b'123') + @unittest.skipUnless(dpctl.has_sycl_platforms(), + "No SYCL devices except the default host device.") def test_memcpy_type_error (self): mobj = self._create_memory() q = dpctl.get_current_queue() diff --git a/dpctl/tests/test_sycl_usm.py b/dpctl/tests/test_sycl_usm.py index 6a1d5ddc2f..e82301b078 100644 --- a/dpctl/tests/test_sycl_usm.py +++ b/dpctl/tests/test_sycl_usm.py @@ -29,6 +29,8 @@ class TestMemory (unittest.TestCase): + @unittest.skipUnless(dpctl.has_sycl_platforms(), + "No SYCL devices except the default host device.") def test_memory_create (self): nbytes = 1024 queue = dpctl.get_current_queue() @@ -41,6 +43,8 @@ def _create_memory (self): mobj = MemoryUSMShared(nbytes, queue) return mobj + @unittest.skipUnless(dpctl.has_sycl_platforms(), + "No SYCL devices except the default host device.") def test_memory_without_context (self): mobj = self._create_memory() @@ -81,7 +85,8 @@ def test_memory_gpu_context (self): usm_type = mobj._usm_type(current_queue) self.assertTrue(usm_type in ['unknown', 'shared']) - + @unittest.skipUnless(dpctl.has_sycl_platforms(), + "No SYCL devices except the default host device.") def test_buffer_protocol (self): mobj = self._create_memory() mv1 = memoryview(mobj) @@ -95,12 +100,16 @@ class TestMemoryUSMBase: MemoryUSMClass = None usm_type = None + @unittest.skipUnless(dpctl.has_sycl_platforms(), + "No SYCL devices except the default host device.") def test_create_with_queue (self): q = dpctl.get_current_queue() m = self.MemoryUSMClass(1024, q) self.assertEqual(m.nbytes, 1024) self.assertEqual(m._usm_type(), self.usm_type) + @unittest.skipUnless(dpctl.has_sycl_platforms(), + "No SYCL devices except the default host device.") def test_create_without_queue (self): m = self.MemoryUSMClass(1024) self.assertEqual(m.nbytes, 1024)