File indexing completed on 2024-04-21 04:01:29

 /* -*- C++ -*-
     This file is part of ThreadWeaver.
 
     SPDX-FileCopyrightText: 2005-2013 Mirko Boehm <mirko@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include <QMutexLocker>
 
 #include "debuggingaids.h"
 #include "destructedstate.h"
 #include "inconstructionstate.h"
 #include "queuepolicy.h"
 #include "shuttingdownstate.h"
 #include "suspendedstate.h"
 #include "suspendingstate.h"
 #include "weaver_p.h"
 #include "workinghardstate.h"
 
 namespace ThreadWeaver
 {
 namespace Private
 {
 Weaver_Private::Weaver_Private()
     : QueueSignals_Private()
     , active(0)
     , inventoryMax(qMax(4, 2 * QThread::idealThreadCount()))
     , mutex(new QMutex)
 
 {
 }
 
 Weaver_Private::~Weaver_Private()
 {
     // FIXME no need for dynamic allocation
     delete mutex;
 }
 
 /** @brief Dump the current jobs to the console.
  *
  * Use at your own risk.
  */
 void Weaver_Private::dumpJobs()
 {
     QMutexLocker l(mutex);
     Q_UNUSED(l);
     TWDEBUG(0, "WeaverImpl::dumpJobs: current jobs:\n");
     for (int index = 0; index < assignments.size(); ++index) {
         TWDEBUG(0,
                 "--> %4i: %p (priority %i, can be executed: %s)\n",
                 index,
                 (void *)assignments.at(index).data(),
                 assignments.at(index)->priority(),
                 canBeExecuted(assignments.at(index)) ? "yes" : "no");
     }
 }
 
 /** @brief Check with the assigned queue policies if the job can be executed.
  *
  * If it returns true, it expects that the job is executed right after that. The done() methods of the
  * queue policies will be automatically called when the job is finished.
  *
  * If it returns false, all queue policy resources have been freed, and the method can be called again
  * at a later time.
  */
 bool Weaver_Private::canBeExecuted(JobPointer job)
 {
     Q_ASSERT(!mutex->tryLock()); // mutex has to be held when this method is called
 
     QList<QueuePolicy *> acquired;
 
     bool success = true;
 
     QMutexLocker l(job->mutex());
     QList<QueuePolicy *> policies = job->queuePolicies();
     if (!policies.isEmpty()) {
         TWDEBUG(4, "WeaverImpl::canBeExecuted: acquiring permission from %i queue %s.\n", policies.size(), policies.size() == 1 ? "policy" : "policies");
         for (int index = 0; index < policies.size(); ++index) {
             if (policies.at(index)->canRun(job)) {
                 acquired.append(policies.at(index));
             } else {
                 success = false;
                 break;
             }
         }
 
         TWDEBUG(4, "WeaverImpl::canBeExecuted: queue policies returned %s.\n", success ? "true" : "false");
 
         if (!success) {
             for (int index = 0; index < acquired.size(); ++index) {
                 acquired.at(index)->release(job);
             }
         }
     } else {
         TWDEBUG(4, "WeaverImpl::canBeExecuted: no queue policies, this job can be executed.\n");
     }
     return success;
 }
 
 void Weaver_Private::deleteExpiredThreads()
 {
     Q_ASSERT(!mutex->tryLock()); // mutex has to be held when this method is called
     for (Thread *thread : std::as_const(expiredThreads)) {
         thread->wait();
         delete thread;
     }
     expiredThreads.clear();
 }
 
 }
 
 }