[SYCL][NFCI] Remove unnecessary CG type argument in finalizeHandler (#13864)

The `finalizeHandler` function on queue_impl has a `CGType` argument,
but the information in this argument could be queried directly from the
handler instead. This commit removes the argument and makes the member
function call `handler::getType()` instead.

Signed-off-by: Larsen, Steffen <[email protected]>

Author: steffenlarsen

sycl/source/detail/queue_impl.hpp

@@ -778,8 +778,7 @@ class queue_impl {
 
   // template is needed for proper unit testing
   template <typename HandlerType = handler>
-  void finalizeHandler(HandlerType &Handler, const CG::CGTYPE &Type,
-                       event &EventRet) {
+  void finalizeHandler(HandlerType &Handler, event &EventRet) {
     if (MIsInorder) {
       // Accessing and changing of an event isn't atomic operation.
       // Hence, here is the lock for thread-safety.
@@ -807,6 +806,8 @@ class queue_impl {
       EventRet = Handler.finalize();
       EventToBuildDeps = getSyclObjImpl(EventRet);
     } else {
+      const CG::CGTYPE Type = Handler.getType();
+
       // The following code supports barrier synchronization if host task is
       // involved in the scenario. Native barriers cannot handle host task
       // dependency so in the case where some commands were not enqueued
@@ -886,11 +887,11 @@ class queue_impl {
         KernelUsesAssert = !(Handler.MKernel && Handler.MKernel->isInterop()) &&
                            ProgramManager::getInstance().kernelUsesAssert(
                                Handler.MKernelName.c_str());
-      finalizeHandler(Handler, Type, Event);
+      finalizeHandler(Handler, Event);
 
       (*PostProcess)(IsKernel, KernelUsesAssert, Event);
     } else
-      finalizeHandler(Handler, Type, Event);
+      finalizeHandler(Handler, Event);
 
     addEvent(Event);
     return Event;

sycl/unittests/scheduler/InOrderQueueSyncCheck.cpp

@@ -22,6 +22,8 @@ using ::testing::An;
 // Define type with the only methods called by finalizeHandler
 class LimitedHandler {
 public:
+  LimitedHandler(sycl::detail::CG::CGTYPE CGType) : MCGType(CGType) {}
+
   virtual ~LimitedHandler() {}
   virtual void depends_on(const sycl::detail::EventImplPtr &) {}
   virtual void depends_on(const std::vector<detail::EventImplPtr> &Events) {}
@@ -32,12 +34,19 @@ class LimitedHandler {
         std::make_shared<detail::event_impl>();
     return sycl::detail::createSyclObjFromImpl<sycl::event>(NewEvent);
   }
+
+  sycl::detail::CG::CGTYPE getType() { return MCGType; }
+
+  sycl::detail::CG::CGTYPE MCGType;
 };
 
 // Needed to use EXPECT_CALL to verify depends_on that originally appends lst
 // event as dependency to the new CG
 class LimitedHandlerSimulation : public LimitedHandler {
 public:
+  LimitedHandlerSimulation(sycl::detail::CG::CGTYPE CGType)
+      : LimitedHandler(CGType) {}
+
   MOCK_METHOD1(depends_on, void(const sycl::detail::EventImplPtr &));
   MOCK_METHOD1(depends_on, void(event Event));
   MOCK_METHOD1(depends_on,
@@ -67,17 +76,15 @@ TEST_F(SchedulerTest, InOrderQueueSyncCheck) {
   // previous task, this is needed to properly sync blocking & blocked tasks.
   sycl::event Event;
   {
-    LimitedHandlerSimulation MockCGH;
+    LimitedHandlerSimulation MockCGH{detail::CG::CGTYPE::CodeplayHostTask};
     EXPECT_CALL(MockCGH, depends_on(An<const sycl::detail::EventImplPtr &>()))
         .Times(0);
-    Queue->finalizeHandler<LimitedHandlerSimulation>(
-        MockCGH, detail::CG::CGTYPE::CodeplayHostTask, Event);
+    Queue->finalizeHandler<LimitedHandlerSimulation>(MockCGH, Event);
   }
   {
-    LimitedHandlerSimulation MockCGH;
+    LimitedHandlerSimulation MockCGH{detail::CG::CGTYPE::CodeplayHostTask};
     EXPECT_CALL(MockCGH, depends_on(An<const sycl::detail::EventImplPtr &>()))
         .Times(1);
-    Queue->finalizeHandler<LimitedHandlerSimulation>(
-        MockCGH, detail::CG::CGTYPE::CodeplayHostTask, Event);
+    Queue->finalizeHandler<LimitedHandlerSimulation>(MockCGH, Event);
   }
 }