Set Thread Priority In QtConcurrent

From Qt Wiki
Jump to: navigation, search

QThread class have method setPriority(), but QtConcurrent doesn't. So i write own implementation with using call_once function. But current C++ standard does not have this function, it's only in C+0x and BOOST. After some googling i found few implementations and select one. QAtomicInt not ideal class for create thread-safe code and i had to use few undocumented features like QBasicAtomicInt, because it POD type and can be initialized statically inside executable file before all potential parallel initializations inside concurrent threads.

  1. ifndef CALL_ONCE_H
  2. define CALL_ONCE_H
  1. include <QtGlobal>
  2. include <QAtomicInt>
  3. include <QMutex>
  4. include <QWaitCondition>
  5. include <QThreadStorage>
  6. include <QThread>

namespace CallOnce {

enum ECallOnce {
CO_Request,
CO_InProgress,
CO_Finished
};
Q_GLOBAL_STATIC(QThreadStorage<QAtomicInt*>, once_flag)

}

template <class Function>

inline static void qCallOnce(Function func, QBasicAtomicInt& flag)

{

using namespace CallOnce;
int protectFlag = flag.fetchAndStoreAcquire((int)flag);
if (protectFlag  CO_Finished)
       return;
   if (protectFlag  CO_Request && flag.testAndSetRelaxed(protectFlag,
CO_InProgress)) {
func();
flag.fetchAndStoreRelease(CO_Finished);
}
else {
do {
QThread::yieldCurrentThread();
}
while (!flag.testAndSetAcquire(CO_Finished, CO_Finished));
}

}

template <class Function>

inline static void qCallOncePerThread(Function func)

{

using namespace CallOnce;
if (!once_flag()->hasLocalData()) {
once_flag()->setLocalData(new QAtomicInt(CallOnce::CO_Request));
qCallOnce(func, *once_flag()->localData());
}

}

  1. endif // CALL_ONCE_H

This is example how to use this functions for set thread priority once per thread at run:

  1. include <QtGlobal>
  2. include <QtDebug>
  1. include <QTimer>
  1. include <QTime>
  1. include <QVector>
  2. include <QThread>
  3. include <QtConcurrentMap>
  4. include <QtConcurrentFilter>
  5. include <QCoreApplication>
  1. include <algorithm>
  1. include "call_once.h"

enum {Max = 100};

struct run_once {

void operator()()
{
qDebug() << "Functor: This only once…";
}

};

void func_run_once() {

qDebug() << "Function: This only once…";

}

struct inc_functor {

inc_functor() : counter(0) {}
inline int operator()() {return counter;}
int counter;

};

struct setPriorityFunctor {

setPriorityFunctor(QThread::Priority priority = QThread::NormalPriority)
: m_priority(priority) {}
inline void operator()()
{
QThread* thread = QThread::currentThread();
thread->setPriority(m_priority);
}
QThread::Priority m_priority;

};

void setLowestPriorityFunction() {

QThread* thread = QThread::currentThread();
thread->setPriority(QThread::LowestPriority);
qDebug("Current thread %x. Thread set to Lowest priority",
(quintptr)thread);

}

void setHighestPriorityFunction() {

QThread* thread = QThread::currentThread();
thread->setPriority(QThread::HighestPriority);
qDebug("Current thread x. Thread set to Highest priority",
(quintptr)thread);

}

int calculate(const int& num) {

  1. if 0 // Test once call per thread with function
#if 0 // Set lowest thread priority
qCallOncePerThread(setLowestPriorityFunction);
#else // Set highest thread priority
qCallOncePerThread(setHighestPriorityFunction);
#endif
  1. else // Test once call per thread with functor
#if 0
qCallOncePerThread(setPriorityFunctor(QThread::HighestPriority));
#else
qCallOncePerThread(setPriorityFunctor(QThread::LowestPriority));
#endif
  1. endif
return ~num;

}

static QBasicAtomicInt flag = Q_BASIC_ATOMIC_INITIALIZER(CallOnce::CO_Request);

int parityFilter(const int& num) {

qCallOnce(run_once(), flag);
return num 2 ? false : true;

}

static QBasicAtomicInt testflag = Q_BASIC_ATOMIC_INITIALIZER(CallOnce::CO_Request);

int main(int argc, char* argv[]) {

QCoreApplication a(argc, argv);
QTime t; t.start();
for (int i = 0; i < 1000 * 1000 * 100;+i)
qCallOnce(run_once(), testflag);
qDebug("%d ms", t.elapsed());

QVector<int> ints;

std::generate_n(std::back_inserter(ints),

(int)Max, inc_functor());

// Test qCallOnce

{
QVector<int> results = QtConcurrent::blockingMapped(ints, calculate);
qDebug() << results;
}

// Test qCallOncePerThread

{
QtConcurrent::blockingFilter(ints, parityFilter);
qDebug() << ints;
}

return 0; }

Source

P.S.: This implementation faster than boost::call_once, but slower than std::call_once