diff --git a/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp b/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp index f599078a6769e..200f1dc3bb178 100644 --- a/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp +++ b/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp @@ -108,7 +108,7 @@ event submit_with_event_impl(const queue &Q, PropertiesT Props, CommandGroupFunc &&CGF, const sycl::detail::code_location &CodeLoc) { return Q.submit_with_event<__SYCL_USE_FALLBACK_ASSERT>( - Props, detail::type_erased_cgfo_ty{CGF}, nullptr, CodeLoc); + Props, detail::type_erased_cgfo_ty{CGF}, CodeLoc); } } // namespace detail diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp index 494b78a2326e8..fcf49ef6ad6c3 100644 --- a/sycl/include/sycl/handler.hpp +++ b/sycl/include/sycl/handler.hpp @@ -456,14 +456,12 @@ class __SYCL_EXPORT handler { /// is null if no secondary queue is associated with the submission. /// \param CallerNeedsEvent indicates if the event resulting from this handler /// is needed by the caller. -#ifndef __INTEL_PREVIEW_BREAKING_CHANGES // TODO: This function is not used anymore, remove it in the next // ABI-breaking window. handler(std::shared_ptr Queue, std::shared_ptr PrimaryQueue, std::shared_ptr SecondaryQueue, bool CallerNeedsEvent); -#endif __SYCL_DLL_LOCAL handler(std::shared_ptr Queue, detail::queue_impl *SecondaryQueue, bool CallerNeedsEvent); diff --git a/sycl/include/sycl/queue.hpp b/sycl/include/sycl/queue.hpp index a0dbdf5c540e8..36006ac341bb6 100644 --- a/sycl/include/sycl/queue.hpp +++ b/sycl/include/sycl/queue.hpp @@ -66,7 +66,7 @@ auto get_native(const SyclObjectT &Obj) namespace detail { class queue_impl; -inline event submitAssertCapture(const queue &, event &, queue *, +inline event submitAssertCapture(const queue &, event &, const detail::code_location &); // Function to postprocess submitted command @@ -87,8 +87,10 @@ class __SYCL_EXPORT SubmissionInfo { sycl::detail::optional &PostProcessorFunc(); const sycl::detail::optional &PostProcessorFunc() const; +#ifndef __INTEL_PREVIEW_BREAKING_CHANGES std::shared_ptr &SecondaryQueue(); const std::shared_ptr &SecondaryQueue() const; +#endif ext::oneapi::experimental::event_mode_enum &EventMode(); const ext::oneapi::experimental::event_mode_enum &EventMode() const; @@ -434,21 +436,18 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase { /// Submits a command group function object to the queue, in order to be /// scheduled for execution on the device. /// - /// On a kernel error, this command group function object is then scheduled - /// for execution on a secondary queue. - /// /// \param CGF is a function object containing command group. - /// \param SecondaryQueue is a fallback SYCL queue. + /// \param SecondaryQueue is a fallback SYCL queue. (unused) /// \param CodeLoc is the code location of the submit call (default argument) /// \return a SYCL event object, which corresponds to the queue the command /// group is being enqueued on. template std::enable_if_t, event> submit( - T CGF, queue &SecondaryQueue, + T CGF, [[maybe_unused]] queue &SecondaryQueue, const detail::code_location &CodeLoc = detail::code_location::current()) { return submit_with_event<__SYCL_USE_FALLBACK_ASSERT>( sycl::ext::oneapi::experimental::empty_properties_t{}, - detail::type_erased_cgfo_ty{CGF}, &SecondaryQueue, CodeLoc); + detail::type_erased_cgfo_ty{CGF}, CodeLoc); } /// Prevents any commands submitted afterward to this queue from executing @@ -3582,7 +3581,7 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase { -> backend_return_t; #if __SYCL_USE_FALLBACK_ASSERT - friend event detail::submitAssertCapture(const queue &, event &, queue *, + friend event detail::submitAssertCapture(const queue &, event &, const detail::code_location &); #endif @@ -3686,47 +3685,6 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase { const detail::code_location &CodeLoc, bool IsTopCodeLoc) const; - /// Submits a command group function object to the queue, in order to be - /// scheduled for execution on the device. - /// - /// \param Props is a property list with submission properties. - /// \param CGF is a function object containing command group. - /// \param SecondaryQueuePtr is a pointer to the secondary queue. - /// \param CodeLoc is the code location of the submit call (default argument) - /// \return a SYCL event object for the submitted command group. - // - // UseFallBackAssert as template param vs `#if` in function body is necessary - // to prevent ODR-violation between TUs built with different fallback assert - // modes. - template - event submit_with_event(PropertiesT Props, - const detail::type_erased_cgfo_ty &CGF, - queue *SecondaryQueuePtr, - const detail::code_location &CodeLoc = - detail::code_location::current()) const { - detail::tls_code_loc_t TlsCodeLocCapture(CodeLoc); - detail::v1::SubmissionInfo SI{}; - ProcessSubmitProperties(Props, SI); - if (SecondaryQueuePtr) - SI.SecondaryQueue() = detail::getSyclObjImpl(*SecondaryQueuePtr); - if constexpr (UseFallbackAssert) - SI.PostProcessorFunc() = - [this, &SecondaryQueuePtr, - &TlsCodeLocCapture](bool IsKernel, bool KernelUsesAssert, event &E) { - if (IsKernel && !device_has(aspect::ext_oneapi_native_assert) && - KernelUsesAssert && !device_has(aspect::accelerator)) { - // __devicelib_assert_fail isn't supported by Device-side Runtime - // Linking against fallback impl of __devicelib_assert_fail is - // performed by program manager class - // Fallback assert isn't supported for FPGA - submitAssertCapture(*this, E, SecondaryQueuePtr, - TlsCodeLocCapture.query()); - } - }; - return submit_with_event_impl(CGF, SI, TlsCodeLocCapture.query(), - TlsCodeLocCapture.isToplevel()); - } - /// Submits a command group function object to the queue, in order to be /// scheduled for execution on the device. /// @@ -3756,7 +3714,7 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase { // Linking against fallback impl of __devicelib_assert_fail is // performed by program manager class // Fallback assert isn't supported for FPGA - submitAssertCapture(*this, E, nullptr, TlsCodeLocCapture.query()); + submitAssertCapture(*this, E, TlsCodeLocCapture.query()); } }; return submit_with_event_impl(CGF, SI, TlsCodeLocCapture.query(), @@ -3955,7 +3913,6 @@ class AssertInfoCopier; * Submit copy task for assert failure flag and host-task to check the flag * \param Event kernel's event to depend on i.e. the event represents the * kernel to check for assertion failure - * \param SecondaryQueue secondary queue for submit process, null if not used * \returns host tasks event * * This method doesn't belong to queue class to overcome msvc behaviour due to @@ -3963,7 +3920,6 @@ class AssertInfoCopier; * with no proper KernelInfo instance. */ event submitAssertCapture(const queue &Self, event &Event, - queue *SecondaryQueue, const detail::code_location &CodeLoc) { buffer Buffer{1}; @@ -4019,10 +3975,10 @@ event submitAssertCapture(const queue &Self, event &Event, CopierEv = Self.submit_with_event( sycl::ext::oneapi::experimental::empty_properties_t{}, CopierCGF, - SecondaryQueue, CodeLoc); + CodeLoc); CheckerEv = Self.submit_with_event( sycl::ext::oneapi::experimental::empty_properties_t{}, CheckerCGF, - SecondaryQueue, CodeLoc); + CodeLoc); return CheckerEv; } diff --git a/sycl/source/detail/handler_impl.hpp b/sycl/source/detail/handler_impl.hpp index 9dac6a7f435d4..cb6cd2014345c 100644 --- a/sycl/source/detail/handler_impl.hpp +++ b/sycl/source/detail/handler_impl.hpp @@ -31,9 +31,7 @@ enum class HandlerSubmissionState : std::uint8_t { class handler_impl { public: - handler_impl(queue_impl *SubmissionSecondaryQueue, bool EventNeeded) - : MSubmissionSecondaryQueue(SubmissionSecondaryQueue), - MEventNeeded(EventNeeded) {}; + handler_impl(bool EventNeeded) : MEventNeeded(EventNeeded) {}; handler_impl( std::shared_ptr Graph) @@ -67,10 +65,6 @@ class handler_impl { /// Registers mutually exclusive submission states. HandlerSubmissionState MSubmissionState = HandlerSubmissionState::NO_STATE; - /// Pointer to the secondary queue implementation. Nullptr if no - /// secondary queue fallback was given in the associated submission. - queue_impl *MSubmissionSecondaryQueue = nullptr; - /// Bool stores information about whether the event resulting from the /// corresponding work is required. bool MEventNeeded = true; diff --git a/sycl/source/detail/queue_impl.cpp b/sycl/source/detail/queue_impl.cpp index 4cc0ba6fa8853..237b7dfb523ac 100644 --- a/sycl/source/detail/queue_impl.cpp +++ b/sycl/source/detail/queue_impl.cpp @@ -306,18 +306,18 @@ void queue_impl::addEvent(const detail::EventImplPtr &EventImpl) { detail::EventImplPtr queue_impl::submit_impl(const detail::type_erased_cgfo_ty &CGF, - queue_impl *SecondaryQueue, bool CallerNeedsEvent, - const detail::code_location &Loc, bool IsTopCodeLoc, + bool CallerNeedsEvent, const detail::code_location &Loc, + bool IsTopCodeLoc, const v1::SubmissionInfo &SubmitInfo) { #ifdef __INTEL_PREVIEW_BREAKING_CHANGES - detail::handler_impl HandlerImplVal(SecondaryQueue, CallerNeedsEvent); + detail::handler_impl HandlerImplVal(CallerNeedsEvent); detail::handler_impl *HandlerImpl = &HandlerImplVal; // Inlining `Self` results in a crash when SYCL RT is built using MSVC with // optimizations enabled. No crash if built using OneAPI. auto Self = shared_from_this(); handler Handler(HandlerImpl, Self); #else - handler Handler(shared_from_this(), SecondaryQueue, CallerNeedsEvent); + handler Handler(shared_from_this(), CallerNeedsEvent); auto &HandlerImpl = detail::getSyclObjImpl(Handler); #endif @@ -399,8 +399,8 @@ queue_impl::submit_impl(const detail::type_erased_cgfo_ty &CGF, Stream->generateFlushCommand(ServiceCGH); }; detail::type_erased_cgfo_ty CGF{L}; - detail::EventImplPtr FlushEvent = submit_impl( - CGF, SecondaryQueue, /*CallerNeedsEvent*/ true, Loc, IsTopCodeLoc, {}); + detail::EventImplPtr FlushEvent = + submit_impl(CGF, /*CallerNeedsEvent*/ true, Loc, IsTopCodeLoc, {}); if (EventImpl) EventImpl->attachEventToCompleteWeak(FlushEvent); registerStreamServiceEvent(FlushEvent); @@ -409,18 +409,6 @@ queue_impl::submit_impl(const detail::type_erased_cgfo_ty &CGF, return EventImpl; } -#ifndef __INTEL_PREVIEW_BREAKING_CHANGES -detail::EventImplPtr -queue_impl::submit_impl(const detail::type_erased_cgfo_ty &CGF, - const std::shared_ptr & /*PrimaryQueue*/, - const std::shared_ptr &SecondaryQueue, - bool CallerNeedsEvent, const detail::code_location &Loc, - bool IsTopCodeLoc, const SubmissionInfo &SubmitInfo) { - return submit_impl(CGF, SecondaryQueue.get(), CallerNeedsEvent, Loc, - IsTopCodeLoc, SubmitInfo); -} -#endif - template event queue_impl::submitWithHandler(const std::vector &DepEvents, bool CallerNeedsEvent, diff --git a/sycl/source/detail/queue_impl.hpp b/sycl/source/detail/queue_impl.hpp index 4cc3285a0a4d4..402f09921f489 100644 --- a/sycl/source/detail/queue_impl.hpp +++ b/sycl/source/detail/queue_impl.hpp @@ -69,7 +69,9 @@ enum QueueOrder { Ordered, OOO }; // Implementation of the submission information storage. struct SubmissionInfoImpl { optional MPostProcessorFunc = std::nullopt; +#ifndef __INTEL_PREVIEW_BREAKING_CHANGES std::shared_ptr MSecondaryQueue = nullptr; +#endif ext::oneapi::experimental::event_mode_enum MEventMode = ext::oneapi::experimental::event_mode_enum::none; }; @@ -331,22 +333,16 @@ class queue_impl : public std::enable_shared_from_this { /// Submits a command group function object to the queue, in order to be /// scheduled for execution on the device. /// - /// On a kernel error, this command group function object is then scheduled - /// for execution on a secondary queue. - /// /// \param CGF is a function object containing command group. - /// \param SecondQueue is a shared_ptr to the secondary queue. /// \param Loc is the code location of the submit call (default argument) /// \param StoreAdditionalInfo makes additional info be stored in event_impl /// \return a SYCL event object, which corresponds to the queue the command /// group is being enqueued on. event submit(const detail::type_erased_cgfo_ty &CGF, - const std::shared_ptr &SecondQueue, const detail::code_location &Loc, bool IsTopCodeLoc, const SubmitPostProcessF *PostProcess = nullptr) { event ResEvent; v1::SubmissionInfo SI{}; - SI.SecondaryQueue() = SecondQueue; if (PostProcess) SI.PostProcessorFunc() = *PostProcess; return submit_with_event(CGF, SI, Loc, IsTopCodeLoc); @@ -364,9 +360,8 @@ class queue_impl : public std::enable_shared_from_this { const v1::SubmissionInfo &SubmitInfo, const detail::code_location &Loc, bool IsTopCodeLoc) { - detail::EventImplPtr ResEvent = - submit_impl(CGF, SubmitInfo.SecondaryQueue().get(), - /*CallerNeedsEvent=*/true, Loc, IsTopCodeLoc, SubmitInfo); + detail::EventImplPtr ResEvent = submit_impl(CGF, /*CallerNeedsEvent=*/true, + Loc, IsTopCodeLoc, SubmitInfo); return createSyclObjFromImpl(ResEvent); } @@ -374,8 +369,7 @@ class queue_impl : public std::enable_shared_from_this { const v1::SubmissionInfo &SubmitInfo, const detail::code_location &Loc, bool IsTopCodeLoc) { - submit_impl(CGF, SubmitInfo.SecondaryQueue().get(), - /*CallerNeedsEvent=*/false, Loc, IsTopCodeLoc, SubmitInfo); + submit_impl(CGF, /*CallerNeedsEvent=*/false, Loc, IsTopCodeLoc, SubmitInfo); } /// Performs a blocking wait for the completion of all enqueued tasks in the @@ -878,38 +872,15 @@ class queue_impl : public std::enable_shared_from_this { PostProcess(IsKernel, KernelUsesAssert, Event); } -#ifndef __INTEL_PREVIEW_BREAKING_CHANGES - /// Performs command group submission to the queue. - /// - /// \param CGF is a function object containing command group. - /// \param PrimaryQueue is a pointer to the primary queue. This may be the - /// same as this. - /// \param SecondaryQueue is a pointer to the secondary queue. This may be the - /// same as this. - /// \param CallerNeedsEvent is a boolean indicating whether the event is - /// required by the user after the call. - /// \param Loc is the code location of the submit call (default argument) - /// \param SubmitInfo is additional optional information for the submission. - /// \return a SYCL event representing submitted command group. - detail::EventImplPtr - submit_impl(const detail::type_erased_cgfo_ty &CGF, - const std::shared_ptr &PrimaryQueue, - const std::shared_ptr &SecondaryQueue, - bool CallerNeedsEvent, const detail::code_location &Loc, - bool IsTopCodeLoc, const SubmissionInfo &SubmitInfo); -#endif - /// Performs command group submission to the queue. /// /// \param CGF is a function object containing command group. - /// \param SecondaryQueue is a pointer to the secondary queue. /// \param CallerNeedsEvent is a boolean indicating whether the event is /// required by the user after the call. /// \param Loc is the code location of the submit call (default argument) /// \param SubmitInfo is additional optional information for the submission. /// \return a SYCL event representing submitted command group. detail::EventImplPtr submit_impl(const detail::type_erased_cgfo_ty &CGF, - queue_impl *SecondaryQueue, bool CallerNeedsEvent, const detail::code_location &Loc, bool IsTopCodeLoc, diff --git a/sycl/source/detail/scheduler/scheduler.hpp b/sycl/source/detail/scheduler/scheduler.hpp index 69448ca817937..8b4600eb1c05b 100644 --- a/sycl/source/detail/scheduler/scheduler.hpp +++ b/sycl/source/detail/scheduler/scheduler.hpp @@ -591,14 +591,6 @@ class Scheduler { void cleanupCommand(Command *Cmd, bool AllowUnsubmitted = false); - /// Reschedules the command passed using Queue provided. - /// - /// This can lead to rescheduling of all dependent commands. This can be - /// used when the user provides a "secondary" queue to the submit method - /// which may be used when the command fails to enqueue/execute in the - /// primary queue. - void rescheduleCommand(Command *Cmd, const QueueImplPtr &Queue); - /// \return a pointer to the corresponding memory object record for the /// SYCL memory object provided, or nullptr if it does not exist. MemObjRecord *getMemObjRecord(SYCLMemObjI *MemObject); diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp index a3ac355b6fd8b..63a5c493c76a8 100644 --- a/sycl/source/handler.cpp +++ b/sycl/source/handler.cpp @@ -316,8 +316,7 @@ fill_copy_args(detail::handler_impl *impl, handler::handler(const std::shared_ptr &Queue, bool CallerNeedsEvent) - : MImplOwner(std::make_shared(Queue.get(), - CallerNeedsEvent)), + : MImplOwner(std::make_shared(CallerNeedsEvent)), impl(MImplOwner.get()), MQueue(Queue) {} handler::handler(detail::handler_impl *HandlerImpl, @@ -328,7 +327,7 @@ handler::handler(detail::handler_impl *HandlerImpl, handler::handler(std::shared_ptr Queue, bool CallerNeedsEvent) - : impl(std::make_shared(nullptr, CallerNeedsEvent)), + : impl(std::make_shared(CallerNeedsEvent)), MQueue(std::move(Queue)) {} #ifndef __INTEL_PREVIEW_BREAKING_CHANGES @@ -337,17 +336,17 @@ handler::handler(std::shared_ptr Queue, handler::handler( std::shared_ptr Queue, [[maybe_unused]] std::shared_ptr PrimaryQueue, - std::shared_ptr SecondaryQueue, bool CallerNeedsEvent) - : impl(std::make_shared(SecondaryQueue.get(), - CallerNeedsEvent)), + [[maybe_unused]] std::shared_ptr SecondaryQueue, + bool CallerNeedsEvent) + : impl(std::make_shared(CallerNeedsEvent)), MQueue(Queue) {} -#endif handler::handler(std::shared_ptr Queue, - detail::queue_impl *SecondaryQueue, bool CallerNeedsEvent) - : impl(std::make_shared(SecondaryQueue, - CallerNeedsEvent)), + [[maybe_unused]] detail::queue_impl *SecondaryQueue, + bool CallerNeedsEvent) + : impl(std::make_shared(CallerNeedsEvent)), MQueue(std::move(Queue)) {} +#endif handler::handler( std::shared_ptr Graph) @@ -1902,14 +1901,6 @@ void handler::use_kernel_bundle( "Context associated with the primary queue is different from the " "context associated with the kernel bundle"); - if (impl->MSubmissionSecondaryQueue && - impl->MSubmissionSecondaryQueue->get_context() != - ExecBundle.get_context()) - throw sycl::exception( - make_error_code(errc::invalid), - "Context associated with the secondary queue is different from the " - "context associated with the kernel bundle"); - setStateExplicitKernelBundle(); setHandlerKernelBundle(detail::getSyclObjImpl(ExecBundle)); } diff --git a/sycl/source/queue.cpp b/sycl/source/queue.cpp index 8b39334f5b432..0fb191660312d 100644 --- a/sycl/source/queue.cpp +++ b/sycl/source/queue.cpp @@ -33,6 +33,7 @@ const optional &SubmissionInfo::PostProcessorFunc() const { return impl->MPostProcessorFunc; } +#ifndef __INTEL_PREVIEW_BREAKING_CHANGES std::shared_ptr &SubmissionInfo::SecondaryQueue() { return impl->MSecondaryQueue; } @@ -41,6 +42,7 @@ const std::shared_ptr & SubmissionInfo::SecondaryQueue() const { return impl->MSecondaryQueue; } +#endif ext::oneapi::experimental::event_mode_enum &SubmissionInfo::EventMode() { return impl->MEventMode; @@ -209,14 +211,16 @@ event queue::submit_impl(std::function CGH, return submit_with_event_impl(std::move(CGH), {}, CodeLoc, IsTopCodeLoc); } -event queue::submit_impl(std::function CGH, queue SecondQueue, +event queue::submit_impl(std::function CGH, + [[maybe_unused]] queue SecondQueue, const detail::code_location &CodeLoc) { - return impl->submit(CGH, SecondQueue.impl, CodeLoc, true); + return impl->submit(CGH, CodeLoc, true); } -event queue::submit_impl(std::function CGH, queue SecondQueue, +event queue::submit_impl(std::function CGH, + [[maybe_unused]] queue SecondQueue, const detail::code_location &CodeLoc, bool IsTopCodeLoc) { - return impl->submit(CGH, SecondQueue.impl, CodeLoc, IsTopCodeLoc); + return impl->submit(CGH, CodeLoc, IsTopCodeLoc); } void queue::submit_without_event_impl(std::function CGH, @@ -245,17 +249,16 @@ event queue::submit_impl_and_postprocess( } event queue::submit_impl_and_postprocess( - std::function CGH, queue SecondQueue, + std::function CGH, [[maybe_unused]] queue SecondQueue, const detail::code_location &CodeLoc, const detail::SubmitPostProcessF &PostProcess) { - return impl->submit(CGH, SecondQueue.impl, CodeLoc, true, &PostProcess); + return impl->submit(CGH, CodeLoc, true, &PostProcess); } event queue::submit_impl_and_postprocess( - std::function CGH, queue SecondQueue, + std::function CGH, [[maybe_unused]] queue SecondQueue, const detail::code_location &CodeLoc, const detail::SubmitPostProcessF &PostProcess, bool IsTopCodeLoc) { - return impl->submit(CGH, SecondQueue.impl, CodeLoc, IsTopCodeLoc, - &PostProcess); + return impl->submit(CGH, CodeLoc, IsTopCodeLoc, &PostProcess); } event queue::submit_with_event_impl(std::function CGH, diff --git a/sycl/unittests/SYCL2020/KernelBundle.cpp b/sycl/unittests/SYCL2020/KernelBundle.cpp index 5ffe4ecbc341a..3748f002ba88c 100644 --- a/sycl/unittests/SYCL2020/KernelBundle.cpp +++ b/sycl/unittests/SYCL2020/KernelBundle.cpp @@ -262,98 +262,6 @@ TEST(KernelBundle, UseKernelBundleWrongContextPrimaryQueueOnly) { } } -TEST(KernelBundle, UseKernelBundleWrongContextPrimaryQueueValidSecondaryQueue) { - sycl::unittest::UrMock<> Mock; - - const sycl::device Dev = sycl::platform().get_devices()[0]; - const sycl::context PrimaryCtx{Dev}; - const sycl::context SecondaryCtx{Dev}; - - ASSERT_NE(PrimaryCtx, SecondaryCtx); - - auto KernelBundle = sycl::get_kernel_bundle( - SecondaryCtx, {Dev}); - - sycl::queue PrimaryQueue{PrimaryCtx, Dev}; - sycl::queue SecondaryQueue{SecondaryCtx, Dev}; - - class UnqiueException {}; - - try { - PrimaryQueue.submit( - [&](sycl::handler &CGH) { - try { - CGH.use_kernel_bundle(KernelBundle); - FAIL() << "No exception was thrown."; - CGH.single_task([]() {}); - } catch (const sycl::exception &e) { - ASSERT_EQ(e.code().value(), static_cast(sycl::errc::invalid)) - << "sycl::exception code was not the expected " - "sycl::errc::invalid."; - // Throw uniquely identifiable exception to distinguish between that - // the sycl::exception originates from the correct level. - throw UnqiueException{}; - } catch (...) { - FAIL() << "Unexpected exception was thrown in kernel invocation " - "function."; - } - }, - SecondaryQueue); - } catch (const UnqiueException &) { - // Expected path - } catch (const sycl::exception &) { - FAIL() << "sycl::exception thrown at the wrong level."; - } catch (...) { - FAIL() << "Unexpected exception was thrown in submit."; - } -} - -TEST(KernelBundle, UseKernelBundleValidPrimaryQueueWrongContextSecondaryQueue) { - sycl::unittest::UrMock<> Mock; - - const sycl::device Dev = sycl::platform().get_devices()[0]; - const sycl::context PrimaryCtx{Dev}; - const sycl::context SecondaryCtx{Dev}; - - ASSERT_NE(PrimaryCtx, SecondaryCtx); - - auto KernelBundle = sycl::get_kernel_bundle( - PrimaryCtx, {Dev}); - - sycl::queue PrimaryQueue{PrimaryCtx, Dev}; - sycl::queue SecondaryQueue{SecondaryCtx, Dev}; - - class UnqiueException {}; - - try { - PrimaryQueue.submit( - [&](sycl::handler &CGH) { - try { - CGH.use_kernel_bundle(KernelBundle); - FAIL() << "No exception was thrown."; - CGH.single_task([]() {}); - } catch (const sycl::exception &e) { - ASSERT_EQ(e.code().value(), static_cast(sycl::errc::invalid)) - << "sycl::exception code was not the expected " - "sycl::errc::invalid."; - // Throw uniquely identifiable exception to distinguish between that - // the sycl::exception originates from the correct level. - throw UnqiueException{}; - } catch (...) { - FAIL() << "Unexpected exception was thrown in kernel invocation " - "function."; - } - }, - SecondaryQueue); - } catch (const UnqiueException &) { - // Expected path - } catch (const sycl::exception &) { - FAIL() << "sycl::exception thrown at the wrong level."; - } catch (...) { - FAIL() << "Unexpected exception was thrown in submit."; - } -} - TEST(KernelBundle, UseKernelBundleWrongContextPrimaryQueueAndSecondaryQueue) { sycl::unittest::UrMock<> Mock; @@ -372,32 +280,22 @@ TEST(KernelBundle, UseKernelBundleWrongContextPrimaryQueueAndSecondaryQueue) { sycl::queue PrimaryQueue{PrimaryCtx, Dev}; sycl::queue SecondaryQueue{SecondaryCtx, Dev}; - class UnqiueException {}; - + size_t EnqueueCounter = 0; try { PrimaryQueue.submit( [&](sycl::handler &CGH) { - try { - CGH.use_kernel_bundle(KernelBundle); - FAIL() << "No exception was thrown."; - CGH.single_task([]() {}); - } catch (const sycl::exception &e) { - ASSERT_EQ(e.code().value(), static_cast(sycl::errc::invalid)) - << "sycl::exception code was not the expected " - "sycl::errc::invalid."; - // Throw uniquely identifiable exception to distinguish between that - // the sycl::exception originates from the correct level. - throw UnqiueException{}; - } catch (...) { - FAIL() << "Unexpected exception was thrown in kernel invocation " - "function."; - } + CGH.use_kernel_bundle(KernelBundle); + ++EnqueueCounter; + CGH.single_task([]() {}); }, SecondaryQueue); - } catch (const UnqiueException &) { - // Expected path - } catch (const sycl::exception &) { - FAIL() << "sycl::exception thrown at the wrong level."; + FAIL() << "Submit should always throw."; + } catch (const sycl::exception &e) { + ASSERT_EQ(EnqueueCounter, size_t{0}) + << "Exception was not thrown from primary queue."; + ASSERT_EQ(e.code().value(), static_cast(sycl::errc::invalid)) + << "sycl::exception code was not the expected " + "sycl::errc::invalid."; } catch (...) { FAIL() << "Unexpected exception was thrown in submit."; } diff --git a/sycl/unittests/scheduler/HostTaskAndBarrier.cpp b/sycl/unittests/scheduler/HostTaskAndBarrier.cpp index 8c68af2c53b79..0fb1daef32f51 100644 --- a/sycl/unittests/scheduler/HostTaskAndBarrier.cpp +++ b/sycl/unittests/scheduler/HostTaskAndBarrier.cpp @@ -62,25 +62,24 @@ class BarrierHandlingWithHostTask : public ::testing::Test { auto L = [&](handler &CGH) { CGH.host_task(BlockHostTask ? CustomHostLambda : [] {}); }; - return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L}, nullptr, - {}, true); + return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L}, {}, + true); } else if (Type == TestCGType::KERNEL_TASK) { auto L = [&](handler &CGH) { CGH.single_task>([] {}); }; - return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L}, nullptr, - {}, true); + return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L}, {}, + true); } else // (Type == TestCGType::BARRIER) { auto L = [&](handler &CGH) { CGH.ext_oneapi_barrier(); }; - return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L}, nullptr, - {}, true); + return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L}, {}, + true); } } sycl::event InsertBarrierWithWaitList(const std::vector &WaitList) { auto L = [&](handler &CGH) { CGH.ext_oneapi_barrier(WaitList); }; - return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L}, nullptr, - {}, true); + return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L}, {}, true); } void BuildAndCheckInnerQueueState(std::vector &Events) {