Revert "[SYCL] Remove secondary submission queue from handler (#17967)"

This reverts commit 08d11bc.

Author: uditagarwal97

sycl/source/detail/handler_impl.hpp

@@ -31,8 +31,10 @@ enum class HandlerSubmissionState : std::uint8_t {
 
 class handler_impl {
 public:
-  handler_impl(queue_impl *SubmissionPrimaryQueue, bool EventNeeded)
+  handler_impl(queue_impl *SubmissionPrimaryQueue,
+               queue_impl *SubmissionSecondaryQueue, bool EventNeeded)
       : MSubmissionPrimaryQueue(SubmissionPrimaryQueue),
+        MSubmissionSecondaryQueue(SubmissionSecondaryQueue),
         MEventNeeded(EventNeeded) {};
 
   handler_impl(
@@ -72,6 +74,12 @@ class handler_impl {
   /// a fallback from a previous submission.
   queue_impl *MSubmissionPrimaryQueue = nullptr;
 
+  /// Shared pointer to the secondary queue implementation. Nullptr if no
+  /// secondary queue fallback was given in the associated submission. This is
+  /// equal to the queue associated with the handler if the corresponding
+  /// submission is a fallback from a previous submission.
+  queue_impl *MSubmissionSecondaryQueue = nullptr;
+
   /// Bool stores information about whether the event resulting from the
   /// corresponding work is required.
   bool MEventNeeded = true;

sycl/source/handler.cpp

@@ -314,28 +314,26 @@ fill_copy_args(detail::handler_impl *impl,
 
 handler::handler(std::shared_ptr<detail::queue_impl> Queue,
                  bool CallerNeedsEvent)
-    : impl(std::make_shared<detail::handler_impl>(Queue.get(),
+    : impl(std::make_shared<detail::handler_impl>(Queue.get(), nullptr,
                                                   CallerNeedsEvent)),
       MQueue(std::move(Queue)) {}
 
 #ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 // TODO: This function is not used anymore, remove it in the next
 // ABI-breaking window.
-handler::handler(
-    std::shared_ptr<detail::queue_impl> Queue,
-    std::shared_ptr<detail::queue_impl> PrimaryQueue,
-    [[maybe_unused]] std::shared_ptr<detail::queue_impl> SecondaryQueue,
-    bool CallerNeedsEvent)
-    : impl(std::make_shared<detail::handler_impl>(PrimaryQueue.get(),
-                                                  CallerNeedsEvent)),
+handler::handler(std::shared_ptr<detail::queue_impl> Queue,
+                 std::shared_ptr<detail::queue_impl> PrimaryQueue,
+                 std::shared_ptr<detail::queue_impl> SecondaryQueue,
+                 bool CallerNeedsEvent)
+    : impl(std::make_shared<detail::handler_impl>(
+          PrimaryQueue.get(), SecondaryQueue.get(), CallerNeedsEvent)),
       MQueue(Queue) {}
 #endif
 
 handler::handler(std::shared_ptr<detail::queue_impl> Queue,
                  detail::queue_impl *PrimaryQueue,
-                 [[maybe_unused]] detail::queue_impl *SecondaryQueue,
-                 bool CallerNeedsEvent)
-    : impl(std::make_shared<detail::handler_impl>(PrimaryQueue,
+                 detail::queue_impl *SecondaryQueue, bool CallerNeedsEvent)
+    : impl(std::make_shared<detail::handler_impl>(PrimaryQueue, SecondaryQueue,
                                                   CallerNeedsEvent)),
       MQueue(std::move(Queue)) {}
 
@@ -1777,6 +1775,14 @@ 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));
 }
@@ -1922,28 +1928,34 @@ void handler::verifyDeviceHasProgressGuarantee(
 }
 
 bool handler::supportsUSMMemcpy2D() {
-  auto &PrimQueue = impl->MSubmissionPrimaryQueue;
-  if (PrimQueue)
-    return checkContextSupports(PrimQueue->getContextImplPtr(),
-                                UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT);
-  else
-    // Return true when handler_impl is constructed with a graph.
-    return true;
+  for (detail::queue_impl *QueueImpl :
+       {impl->MSubmissionPrimaryQueue, impl->MSubmissionSecondaryQueue}) {
+    if (QueueImpl &&
+        !checkContextSupports(QueueImpl->getContextImplPtr(),
+                              UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT))
+      return false;
+  }
+  return true;
 }
 
 bool handler::supportsUSMFill2D() {
-  auto &PrimQueue = impl->MSubmissionPrimaryQueue;
-  if (PrimQueue)
-    return checkContextSupports(PrimQueue->getContextImplPtr(),
-                                UR_CONTEXT_INFO_USM_FILL2D_SUPPORT);
-  else
-    // Return true when handler_impl is constructed with a graph.
-    return true;
+  for (detail::queue_impl *QueueImpl :
+       {impl->MSubmissionPrimaryQueue, impl->MSubmissionSecondaryQueue}) {
+    if (QueueImpl && !checkContextSupports(QueueImpl->getContextImplPtr(),
+                                           UR_CONTEXT_INFO_USM_FILL2D_SUPPORT))
+      return false;
+  }
+  return true;
 }
 
 bool handler::supportsUSMMemset2D() {
-  // memset use the same UR check as fill2D.
-  return supportsUSMFill2D();
+  for (detail::queue_impl *QueueImpl :
+       {impl->MSubmissionPrimaryQueue, impl->MSubmissionSecondaryQueue}) {
+    if (QueueImpl && !checkContextSupports(QueueImpl->getContextImplPtr(),
+                                           UR_CONTEXT_INFO_USM_FILL2D_SUPPORT))
+      return false;
+  }
+  return true;
 }
 
 id<2> handler::computeFallbackKernelBounds(size_t Width, size_t Height) {

sycl/unittests/SYCL2020/KernelBundle.cpp

@@ -308,6 +308,52 @@ TEST(KernelBundle, UseKernelBundleWrongContextPrimaryQueueValidSecondaryQueue) {
   }
 }
 
+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<sycl::bundle_state::executable>(
+      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<TestKernel>([]() {});
+          } catch (const sycl::exception &e) {
+            ASSERT_EQ(e.code().value(), static_cast<int>(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;