[SYCL] Use lock_guard to lock mutex

Signed-off-by: Alexander Flegontov <[email protected]>

Author: alexanderfle

sycl/source/detail/scheduler/commands.cpp

@@ -1797,7 +1797,6 @@ cl_int ExecCGCommand::enqueueImp() {
 
     // Run OpenCL kernel
     sycl::context Context = MQueue->get_context();
-    const detail::plugin &Plugin = MQueue->getPlugin();
     RT::PiKernel Kernel = nullptr;
     std::mutex *KernelMutex = nullptr;
 
@@ -1810,65 +1809,75 @@ cl_int ExecCGCommand::enqueueImp() {
           detail::ProgramManager::getInstance().getOrCreateKernel(
               ExecKernel->MOSModuleHandle, Context, ExecKernel->MKernelName,
               nullptr);
-      KernelMutex->lock();
     }
 
-    for (ArgDesc &Arg : ExecKernel->MArgs) {
-      switch (Arg.MType) {
-      case kernel_param_kind_t::kind_accessor: {
-        Requirement *Req = (Requirement *)(Arg.MPtr);
-        AllocaCommandBase *AllocaCmd = getAllocaForReq(Req);
-        RT::PiMem MemArg = (RT::PiMem)AllocaCmd->getMemAllocation();
-        if (Plugin.getBackend() == backend::opencl) {
+    auto SetKernelParamsAndLaunch = [this, &ExecKernel, &Kernel, &NDRDesc,
+                                     &RawEvents, &Event] {
+      const detail::plugin &Plugin = MQueue->getPlugin();
+      for (ArgDesc &Arg : ExecKernel->MArgs) {
+        switch (Arg.MType) {
+        case kernel_param_kind_t::kind_accessor: {
+          Requirement *Req = (Requirement *)(Arg.MPtr);
+          AllocaCommandBase *AllocaCmd = getAllocaForReq(Req);
+          RT::PiMem MemArg = (RT::PiMem)AllocaCmd->getMemAllocation();
+          if (Plugin.getBackend() == backend::opencl) {
+            Plugin.call<PiApiKind::piKernelSetArg>(Kernel, Arg.MIndex,
+                                                   sizeof(RT::PiMem), &MemArg);
+          } else {
+            Plugin.call<PiApiKind::piextKernelSetArgMemObj>(Kernel, Arg.MIndex,
+                                                            &MemArg);
+          }
+          break;
+        }
+        case kernel_param_kind_t::kind_std_layout: {
+          Plugin.call<PiApiKind::piKernelSetArg>(Kernel, Arg.MIndex, Arg.MSize,
+                                                 Arg.MPtr);
+          break;
+        }
+        case kernel_param_kind_t::kind_sampler: {
+          sampler *SamplerPtr = (sampler *)Arg.MPtr;
+          RT::PiSampler Sampler =
+              detail::getSyclObjImpl(*SamplerPtr)
+                  ->getOrCreateSampler(MQueue->get_context());
           Plugin.call<PiApiKind::piKernelSetArg>(Kernel, Arg.MIndex,
-                                                 sizeof(RT::PiMem), &MemArg);
-        } else {
-          Plugin.call<PiApiKind::piextKernelSetArgMemObj>(Kernel, Arg.MIndex,
-                                                          &MemArg);
+                                                 sizeof(cl_sampler), &Sampler);
+          break;
+        }
+        case kernel_param_kind_t::kind_pointer: {
+          Plugin.call<PiApiKind::piextKernelSetArgPointer>(Kernel, Arg.MIndex,
+                                                           Arg.MSize, Arg.MPtr);
+          break;
+        }
         }
-        break;
-      }
-      case kernel_param_kind_t::kind_std_layout: {
-        Plugin.call<PiApiKind::piKernelSetArg>(Kernel, Arg.MIndex, Arg.MSize,
-                                               Arg.MPtr);
-        break;
-      }
-      case kernel_param_kind_t::kind_sampler: {
-        sampler *SamplerPtr = (sampler *)Arg.MPtr;
-        RT::PiSampler Sampler =
-            detail::getSyclObjImpl(*SamplerPtr)->getOrCreateSampler(Context);
-        Plugin.call<PiApiKind::piKernelSetArg>(Kernel, Arg.MIndex,
-                                               sizeof(cl_sampler), &Sampler);
-        break;
-      }
-      case kernel_param_kind_t::kind_pointer: {
-        Plugin.call<PiApiKind::piextKernelSetArgPointer>(Kernel, Arg.MIndex,
-                                                         Arg.MSize, Arg.MPtr);
-        break;
-      }
       }
-    }
-
-    adjustNDRangePerKernel(NDRDesc, Kernel,
-                           *(detail::getSyclObjImpl(MQueue->get_device())));
 
-    // Some PI Plugins (like OpenCL) require this call to enable USM
-    // For others, PI will turn this into a NOP.
-    Plugin.call<PiApiKind::piKernelSetExecInfo>(Kernel, PI_USM_INDIRECT_ACCESS,
-                                                sizeof(pi_bool), &PI_TRUE);
+      adjustNDRangePerKernel(NDRDesc, Kernel,
+                             *(detail::getSyclObjImpl(MQueue->get_device())));
 
-    // Remember this information before the range dimensions are reversed
-    const bool HasLocalSize = (NDRDesc.LocalSize[0] != 0);
+      // Some PI Plugins (like OpenCL) require this call to enable USM
+      // For others, PI will turn this into a NOP.
+      Plugin.call<PiApiKind::piKernelSetExecInfo>(
+          Kernel, PI_USM_INDIRECT_ACCESS, sizeof(pi_bool), &PI_TRUE);
 
-    ReverseRangeDimensionsForKernel(NDRDesc);
+      // Remember this information before the range dimensions are reversed
+      const bool HasLocalSize = (NDRDesc.LocalSize[0] != 0);
 
-    pi_result Error = Plugin.call_nocheck<PiApiKind::piEnqueueKernelLaunch>(
-        MQueue->getHandleRef(), Kernel, NDRDesc.Dims, &NDRDesc.GlobalOffset[0],
-        &NDRDesc.GlobalSize[0], HasLocalSize ? &NDRDesc.LocalSize[0] : nullptr,
-        RawEvents.size(), RawEvents.empty() ? nullptr : &RawEvents[0], &Event);
+      ReverseRangeDimensionsForKernel(NDRDesc);
+      pi_result Error = Plugin.call_nocheck<PiApiKind::piEnqueueKernelLaunch>(
+          MQueue->getHandleRef(), Kernel, NDRDesc.Dims,
+          &NDRDesc.GlobalOffset[0], &NDRDesc.GlobalSize[0],
+          HasLocalSize ? &NDRDesc.LocalSize[0] : nullptr, RawEvents.size(),
+          RawEvents.empty() ? nullptr : &RawEvents[0], &Event);
+      return Error;
+    };
 
-    if (KernelMutex != nullptr)
-      KernelMutex->unlock();
+    pi_result Error = PI_SUCCESS;
+    if (KernelMutex != nullptr) {
+      std::lock_guard<std::mutex> Lock(*KernelMutex);
+      Error = SetKernelParamsAndLaunch();
+    } else {
+      Error = SetKernelParamsAndLaunch();
+    }
 
     if (PI_SUCCESS != Error) {
       // If we have got non-success error code, let's analyze it to emit nice

sycl/source/detail/scheduler/scheduler.cpp

@@ -84,6 +84,7 @@ EventImplPtr Scheduler::addCG(std::unique_ptr<detail::CG> CommandGroup,
 
   {
     std::shared_lock<std::shared_timed_mutex> Lock(MGraphLock);
+
     // TODO: Check if lazy mode.
     EnqueueResultT Res;
     bool Enqueued = GraphProcessor::enqueueCommand(NewCmd, Res);