Address comments

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

Author: Alexander Batashev

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

@@ -38,7 +38,8 @@ class queue_impl {
   /// Constructs a SYCL queue from a device using an async_handler and
   /// property_list provided.
   ///
-  /// @param Device is a pointer to device_impl.
+  /// @param Device is a SYCL device that is used to dispatch tasks submitted to
+  /// the queue.
   /// @param AsyncHandler is a SYCL asynchronous exception handler.
   /// @param Order specifies whether the queue being constructed as in-order or
   /// out-of-order.
@@ -53,8 +54,10 @@ class queue_impl {
   /// Constructs a SYCL queue with an async_handler and property_list provided
   /// form a device and a context.
   ///
-  /// @param Device is a pointer to device_impl.
-  /// @param Context is a pointer to context_impl.
+  /// @param Device is a SYCL device that is used to dispatch tasks submitted to
+  /// the queue.
+  /// @param Context is a SYCL context to associate with the queue being
+  /// constructed.
   /// @param AsyncHandler is a SYCL asynchronous exception handler.
   /// @param Order specifies whether the queue being constructed as in-order or
   /// out-of-order.
@@ -73,7 +76,8 @@ class queue_impl {
   /// Constructs a SYCL queue from plugin interoperability handle.
   ///
   /// @param PiQueue is a raw PI queue handle.
-  /// @param Context is a pointer to context_impl.
+  /// @param Context is a SYCL context to associate with the queue being
+  /// constructed.
   /// @param AsyncHandler is a SYCL asynchronous exception handler.
   queue_impl(RT::PiQueue PiQueue, ContextImplPtr Context,
              const async_handler &AsyncHandler)
@@ -114,8 +118,7 @@ class queue_impl {
     return createSyclObjFromImpl<context>(MContext);
   }
 
-  /// @return a pointer to a context_impl.
-  ContextImplPtr getContextImpl() const { return MContext; }
+  ContextImplPtr getContextImplPtr() const { return MContext; }
 
   /// @return an associated SYCL device.
   device get_device() const { return createSyclObjFromImpl<device>(MDevice); }

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->getContextImpl(),
+                                            Queue->getContextImplPtr(),
                                             /*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->getContextImpl());
+      findAllocaForReq(Record, Req, Queue->getContextImplPtr());
   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->getContextImpl());
+      findDepsForReq(Record, Req, Queue->getContextImplPtr());
   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->getContextImpl());
+      findDepsForReq(Record, Req, Queue->getContextImplPtr());
   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()->getContextImpl(),
+      bool Res = sameCtx(AllocaCmd->getQueue()->getContextImplPtr(),
                          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->getContextImpl();
+  Record->MCurContext = Queue->getContextImplPtr();
   return NewCmd;
 }
 
@@ -298,7 +298,7 @@ Command *Scheduler::GraphBuilder::addCopyBack(Requirement *Req) {
     return nullptr;
 
   std::set<Command *> Deps =
-      findDepsForReq(Record, Req, HostQueue->getContextImpl());
+      findDepsForReq(Record, Req, HostQueue->getContextImplPtr());
   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()->getContextImpl(),
+  if (!sameCtx(HostAllocaCmd->getQueue()->getContextImplPtr(),
                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()->getContextImpl());
+            sameCtx(Context, Dep.MDepCommand->getQueue()->getContextImplPtr());
 
       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()->getContextImpl(), Context);
+    bool Res = sameCtx(AllocaCmd->getQueue()->getContextImplPtr(), 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->getContextImpl());
+      findAllocaForReq(Record, Req, Queue->getContextImplPtr());
 
   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->getContextImpl()),
+      UpdateLeaves(findDepsForReq(Record, Req, Queue->getContextImplPtr()),
                    Record, access::mode::read_write);
     } else {
 
@@ -530,7 +530,7 @@ AllocaCommandBase *Scheduler::GraphBuilder::getOrCreateAllocaForReq(
           AllocaCmd->MIsActive = false;
         } else {
           LinkedAllocaCmd->MIsActive = false;
-          Record->MCurContext = Queue->getContextImpl();
+          Record->MCurContext = Queue->getContextImplPtr();
         }
       }
     }
@@ -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->getContextImpl(), Record->MCurContext)) {
+    if (!sameCtx(Queue->getContextImplPtr(), 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->getContextImpl());
+        findDepsForReq(Record, Req, Queue->getContextImplPtr());
 
     for (Command *Dep : Deps)
       NewCmd->addDep(DepDesc{Dep, Req, AllocaCmd});