Fix comments

Signed-off-by: Tikhomirova, Kseniya <[email protected]>

Author: KseniyaTikhomirova

sycl/source/detail/global_handler.cpp

@@ -33,9 +33,6 @@ namespace detail {
 // Origin idea is to track usage of Scheduler from main and other used threads -
 // they increment MCounter; and to use but not add extra reference by our
 // thread_pool threads. For this control MIncrementCounter class member is used.
-// MObj and MReleaseCalled is extra protection needed to handle case when main
-// thread finished but thread_pool is still running and we will join that
-// threads in releaseResources call.
 template <class ResourceHandler> class ObjectUsageCounter {
 public:
   ObjectUsageCounter(std::unique_ptr<ResourceHandler> &Obj, bool ModifyCounter)
@@ -81,7 +78,7 @@ T &GlobalHandler::getOrCreate(InstWithLock<T> &IWL, Types... Args) {
 }
 
 void GlobalHandler::attachScheduler(Scheduler *Scheduler) {
-  // The method is for testing purposes. Do not protect with lock since
+  // The method is used in unit tests only. Do not protect with lock since
   // releaseResources will cause dead lock due to host queue release
   if (MScheduler.Inst)
     MScheduler.Inst->releaseResources();

sycl/source/detail/scheduler/scheduler.hpp

@@ -450,13 +450,13 @@ class Scheduler {
   const QueueImplPtr &getDefaultHostQueue() const { return DefaultHostQueue; }
 
   static MemObjRecord *getMemObjRecord(const Requirement *const Req);
-  // Virtual for testing purposes only
+
   void deferMemObjRelease(const std::shared_ptr<detail::SYCLMemObjI> &MemObj);
 
   Scheduler();
   ~Scheduler();
   void releaseResources();
-  inline bool isDeferredMemObjectsEmpty();
+  bool isDeferredMemObjectsEmpty();
 
 protected:
   using RWLockT = std::shared_timed_mutex;

sycl/source/detail/sycl_mem_obj_t.cpp

@@ -90,8 +90,12 @@ void SYCLMemObjT::updateHostMemory() {
 
   // If we're attached to a memory record, process the deletion of the memory
   // record. We may get detached before we do this.
-  if (MRecord)
-    assert(Scheduler::getInstance().removeMemoryObject(this));
+  if (MRecord) {
+    bool Result = Scheduler::getInstance().removeMemoryObject(this);
+    assert(
+        Result &&
+        "removeMemoryObject should not return false in mem object destructor");
+  }
   releaseHostMem(MShadowCopy);
 
   if (MOpenCLInterop) {

sycl/source/detail/thread_pool.hpp

@@ -30,16 +30,14 @@ class ThreadPool {
   std::mutex MJobQueueMutex;
   std::condition_variable MDoSmthOrStop;
   std::atomic_bool MStop;
-  std::atomic_uint MJobsInExecution;
+  std::atomic_uint MJobsInPool;
 
   void worker() {
     GlobalHandler::instance().registerSchedulerUsage(/*ModifyCounter*/ false);
     std::unique_lock<std::mutex> Lock(MJobQueueMutex);
-    std::thread::id ThisThreadId = std::this_thread::get_id();
     while (true) {
-      MDoSmthOrStop.wait(Lock, [this, &ThisThreadId]() {
-        return !MJobQueue.empty() || MStop.load();
-      });
+      MDoSmthOrStop.wait(
+          Lock, [this]() { return !MJobQueue.empty() || MStop.load(); });
 
       if (MStop.load())
         break;
@@ -52,23 +50,23 @@ class ThreadPool {
 
       Lock.lock();
 
-      MJobsInExecution--;
+      MJobsInPool--;
     }
   }
 
   void start() {
     MLaunchedThreads.reserve(MThreadCount);
 
     MStop.store(false);
-    MJobsInExecution.store(0);
+    MJobsInPool.store(0);
 
     for (size_t Idx = 0; Idx < MThreadCount; ++Idx)
       MLaunchedThreads.emplace_back([this] { worker(); });
   }
 
 public:
   void drain() {
-    while (MJobsInExecution != 0)
+    while (MJobsInPool != 0)
       std::this_thread::yield();
   }
 
@@ -93,7 +91,7 @@ class ThreadPool {
       std::lock_guard<std::mutex> Lock(MJobQueueMutex);
       MJobQueue.emplace([F = std::move(Func)]() { F(); });
     }
-    MJobsInExecution++;
+    MJobsInPool++;
     MDoSmthOrStop.notify_one();
   }
 
@@ -102,7 +100,7 @@ class ThreadPool {
       std::lock_guard<std::mutex> Lock(MJobQueueMutex);
       MJobQueue.emplace(Func);
     }
-    MJobsInExecution++;
+    MJobsInPool++;
     MDoSmthOrStop.notify_one();
   }
 };