Resolve comments

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

Author: Alexander Batashev

sycl/include/CL/sycl/detail/queue_impl.hpp

@@ -115,7 +115,7 @@ class queue_impl {
   }
 
   /// @return a pointer to a context_impl.
-  ContextImplPtr get_context_impl() const { return MContext; }
+  ContextImplPtr getContextImpl() const { return MContext; }
 
   /// @return an associated SYCL device.
   device get_device() const { return createSyclObjFromImpl<device>(MDevice); }
@@ -146,7 +146,7 @@ class queue_impl {
       return submit_impl(CGF, Self);
     } catch (...) {
       {
-        std::lock_guard<mutex_class> guard(MMutex);
+        std::lock_guard<mutex_class> Guard(MMutex);
         MExceptions.PushBack(std::current_exception());
       }
       return SecondQueue->submit(CGF, SecondQueue);
@@ -169,7 +169,7 @@ class queue_impl {
   ///
   /// Synchronous errors will be reported through SYCL exceptions.
   void wait() {
-    std::lock_guard<mutex_class> guard(MMutex);
+    std::lock_guard<mutex_class> Guard(MMutex);
     for (auto &Event : MEvents)
       Event.wait();
     MEvents.clear();
@@ -242,7 +242,7 @@ class queue_impl {
   /// @return a raw PI handle for a free queue. The returned handle is not
   /// retained. It is caller responsibility to make sure queue is still alive.
   RT::PiQueue &getExclusiveQueueHandleRef() {
-    std::lock_guard<mutex_class> guard(MMutex);
+    std::lock_guard<mutex_class> Guard(MMutex);
 
     // To achieve parallelism for FPGA with in order execution model with
     // possibility of two kernels to share data with each other we shall
@@ -271,7 +271,7 @@ class queue_impl {
     {
       // Reduce the scope since this mutex is also
       // locked inside of getExclusiveQueueHandleRef()
-      std::lock_guard<mutex_class> guard(MMutex);
+      std::lock_guard<mutex_class> Guard(MMutex);
 
       if (MQueues.empty()) {
         MQueues.push_back(MCommandQueue);
@@ -325,7 +325,7 @@ class queue_impl {
   ///
   /// @param ExceptionPtr is a pointer to exception to be put.
   void reportAsyncException(std::exception_ptr ExceptionPtr) {
-    std::lock_guard<mutex_class> guard(MMutex);
+    std::lock_guard<mutex_class> Guard(MMutex);
     MExceptions.PushBack(ExceptionPtr);
   }
 
@@ -341,7 +341,7 @@ class queue_impl {
     CGF(Handler);
     event Event = Handler.finalize();
     {
-      std::lock_guard<mutex_class> guard(MMutex);
+      std::lock_guard<mutex_class> Guard(MMutex);
       MEvents.push_back(Event);
     }
     return Event;

sycl/include/CL/sycl/queue.hpp

@@ -227,7 +227,7 @@ class queue {
   /// @param Ptr is a USM pointer to the memory to be prefetched to the device.
   /// @param Count is a number of bytes to be prefetched.
   event prefetch(const void* Ptr, size_t Count) {
-    return submit([=](handler &cgh) { cgh.prefetch(Ptr, Count); });
+    return submit([=](handler &CGH) { CGH.prefetch(Ptr, Count); });
   }
 
   /// single_task version with a kernel represented as a lambda.

sycl/source/detail/scheduler/graph_builder.cpp

@@ -123,7 +123,7 @@ Scheduler::GraphBuilder::getOrInsertMemObjRecord(const QueueImplPtr &Queue,
   MemObject->MRecord.reset(new MemObjRecord{/*MAllocaCommands*/ {},
                                             /*MReadLeaves*/ {},
                                             /*MWriteLeaves*/ {},
-                                            Queue->get_context_impl(),
+                                            Queue->getContextImpl(),
                                             /*MMemModified*/ false});
 
   MMemObjs.push_back(MemObject);
@@ -162,7 +162,7 @@ void Scheduler::GraphBuilder::AddNodeToLeaves(MemObjRecord *Record,
 UpdateHostRequirementCommand *Scheduler::GraphBuilder::insertUpdateHostReqCmd(
     MemObjRecord *Record, Requirement *Req, const QueueImplPtr &Queue) {
   AllocaCommandBase *AllocaCmd =
-      findAllocaForReq(Record, Req, Queue->get_context_impl());
+      findAllocaForReq(Record, Req, Queue->getContextImpl());
   assert(AllocaCmd && "There must be alloca for requirement!");
   UpdateHostRequirementCommand *UpdateCommand =
       new UpdateHostRequirementCommand(Queue, *Req, AllocaCmd, &Req->MData);
@@ -171,7 +171,7 @@ UpdateHostRequirementCommand *Scheduler::GraphBuilder::insertUpdateHostReqCmd(
   const Requirement *StoredReq = UpdateCommand->getRequirement();
 
   std::set<Command *> Deps =
-      findDepsForReq(Record, Req, Queue->get_context_impl());
+      findDepsForReq(Record, Req, Queue->getContextImpl());
   for (Command *Dep : Deps) {
     UpdateCommand->addDep(DepDesc{Dep, StoredReq, AllocaCmd});
     Dep->addUser(UpdateCommand);
@@ -218,7 +218,7 @@ Command *Scheduler::GraphBuilder::insertMemoryMove(MemObjRecord *Record,
     throw runtime_error("Out of host memory");
 
   std::set<Command *> Deps =
-      findDepsForReq(Record, Req, Queue->get_context_impl());
+      findDepsForReq(Record, Req, Queue->getContextImpl());
   Deps.insert(AllocaCmdDst);
   // Get parent allocation of sub buffer to perform full copy of whole buffer
   if (IsSuitableSubReq(Req)) {
@@ -237,7 +237,7 @@ Command *Scheduler::GraphBuilder::insertMemoryMove(MemObjRecord *Record,
     // current context, need to find a parent alloca command for it (it must be
     // there)
     auto IsSuitableAlloca = [Record, Req](AllocaCommandBase *AllocaCmd) {
-      bool Res = sameCtx(AllocaCmd->getQueue()->get_context_impl(),
+      bool Res = sameCtx(AllocaCmd->getQueue()->getContextImpl(),
                          Record->MCurContext) &&
                  // Looking for a parent buffer alloca command
                  AllocaCmd->getType() == Command::CommandType::ALLOCA;
@@ -279,7 +279,7 @@ Command *Scheduler::GraphBuilder::insertMemoryMove(MemObjRecord *Record,
   }
   UpdateLeaves(Deps, Record, access::mode::read_write);
   AddNodeToLeaves(Record, NewCmd, access::mode::read_write);
-  Record->MCurContext = Queue->get_context_impl();
+  Record->MCurContext = Queue->getContextImpl();
   return NewCmd;
 }
 
@@ -298,7 +298,7 @@ Command *Scheduler::GraphBuilder::addCopyBack(Requirement *Req) {
     return nullptr;
 
   std::set<Command *> Deps =
-      findDepsForReq(Record, Req, HostQueue->get_context_impl());
+      findDepsForReq(Record, Req, HostQueue->getContextImpl());
   AllocaCommandBase *SrcAllocaCmd =
       findAllocaForReq(Record, Req, Record->MCurContext);
 
@@ -336,7 +336,7 @@ Command *Scheduler::GraphBuilder::addHostAccessor(Requirement *Req) {
   AllocaCommandBase *HostAllocaCmd =
       getOrCreateAllocaForReq(Record, Req, HostQueue);
 
-  if (!sameCtx(HostAllocaCmd->getQueue()->get_context_impl(),
+  if (!sameCtx(HostAllocaCmd->getQueue()->getContextImpl(),
                Record->MCurContext))
     insertMemoryMove(Record, Req, HostQueue);
 
@@ -418,7 +418,7 @@ Scheduler::GraphBuilder::findDepsForReq(MemObjRecord *Record, Requirement *Req,
       // Going through copying memory between contexts is not supported.
       if (Dep.MDepCommand)
         CanBypassDep &=
-            sameCtx(Context, Dep.MDepCommand->getQueue()->get_context_impl());
+            sameCtx(Context, Dep.MDepCommand->getQueue()->getContextImpl());
 
       if (!CanBypassDep) {
         RetDeps.insert(DepCmd);
@@ -441,7 +441,7 @@ Scheduler::GraphBuilder::findDepsForReq(MemObjRecord *Record, Requirement *Req,
 AllocaCommandBase *Scheduler::GraphBuilder::findAllocaForReq(
     MemObjRecord *Record, Requirement *Req, const ContextImplPtr &Context) {
   auto IsSuitableAlloca = [&Context, Req](AllocaCommandBase *AllocaCmd) {
-    bool Res = sameCtx(AllocaCmd->getQueue()->get_context_impl(), Context);
+    bool Res = sameCtx(AllocaCmd->getQueue()->getContextImpl(), Context);
     if (IsSuitableSubReq(Req)) {
       const Requirement *TmpReq = AllocaCmd->getRequirement();
       Res &= TmpReq->MOffsetInBytes == Req->MOffsetInBytes;
@@ -462,7 +462,7 @@ AllocaCommandBase *Scheduler::GraphBuilder::getOrCreateAllocaForReq(
     MemObjRecord *Record, Requirement *Req, QueueImplPtr Queue) {
 
   AllocaCommandBase *AllocaCmd =
-      findAllocaForReq(Record, Req, Queue->get_context_impl());
+      findAllocaForReq(Record, Req, Queue->getContextImpl());
 
   if (!AllocaCmd) {
     if (IsSuitableSubReq(Req)) {
@@ -477,7 +477,7 @@ AllocaCommandBase *Scheduler::GraphBuilder::getOrCreateAllocaForReq(
       auto *ParentAlloca =
           getOrCreateAllocaForReq(Record, &ParentRequirement, Queue);
       AllocaCmd = new AllocaSubBufCommand(Queue, *Req, ParentAlloca);
-      UpdateLeaves(findDepsForReq(Record, Req, Queue->get_context_impl()),
+      UpdateLeaves(findDepsForReq(Record, Req, Queue->getContextImpl()),
                    Record, access::mode::read_write);
     } else {
 
@@ -530,7 +530,7 @@ AllocaCommandBase *Scheduler::GraphBuilder::getOrCreateAllocaForReq(
           AllocaCmd->MIsActive = false;
         } else {
           LinkedAllocaCmd->MIsActive = false;
-          Record->MCurContext = Queue->get_context_impl();
+          Record->MCurContext = Queue->getContextImpl();
         }
       }
     }
@@ -576,7 +576,7 @@ Scheduler::GraphBuilder::addCG(std::unique_ptr<detail::CG> CommandGroup,
     AllocaCommandBase *AllocaCmd = getOrCreateAllocaForReq(Record, Req, Queue);
     // If there is alloca command we need to check if the latest memory is in
     // required context.
-    if (!sameCtx(Queue->get_context_impl(), Record->MCurContext)) {
+    if (!sameCtx(Queue->getContextImpl(), Record->MCurContext)) {
       // Cannot directly copy memory from OpenCL device to OpenCL device -
       // create two copies: device->host and host->device.
       if (!Queue->is_host() && !Record->MCurContext->is_host())
@@ -585,7 +585,7 @@ Scheduler::GraphBuilder::addCG(std::unique_ptr<detail::CG> CommandGroup,
       insertMemoryMove(Record, Req, Queue);
     }
     std::set<Command *> Deps =
-        findDepsForReq(Record, Req, Queue->get_context_impl());
+        findDepsForReq(Record, Req, Queue->getContextImpl());
 
     for (Command *Dep : Deps)
       NewCmd->addDep(DepDesc{Dep, Req, AllocaCmd});