qt multithreading: calculating an intergral - c++

Question

I need to calculate an integral using the trapezoidal rule and multithreading.
I am using a pool thread that I wrote using a java pool thread example.
#ifndef POOL_H
#define POOL_H
#include <QObject>
#include <QThread>
#include <QWaitCondition>
#include <QMutex>
#include <QQueue>
#include "poolworker.h"
#include "segment.h"
class Segment;
class PoolWorker;
class Pool: public QObject
{
Q_OBJECT
public:
explicit Pool(QObject *parent = 0);
Pool(int nThreads);
void execute(Segment *s);
static QWaitCondition con;
static QMutex poolMutex;
static QQueue<Segment*> segmentQueue;
private:
int nThreads;
QVector<PoolWorker*> workers;
};
#endif // POOL_H
#include "pool.h"
QWaitCondition Pool::con;
QQueue<Segment*> Pool::segmentQueue;
QMutex Pool::poolMutex;
Pool::Pool(QObject *parent) :
QObject(parent)
{
}
Pool::Pool(int nThreads)
{
this->nThreads = nThreads;
for (int i = 0; i < nThreads; i++)
{
workers.push_back(new PoolWorker());
workers[i]->start();
}
}
void Pool::execute(Segment *s)
{
poolMutex.lock();
segmentQueue.enqueue(s);
con.wakeOne();
poolMutex.unlock();
}
#ifndef POOLWORKER_H
#define POOLWORKER_H
#include <QThread>
#include <QMutex>
#include "segment.h"
#include "pool.h"
class PoolWorker : public QThread
{
Q_OBJECT
public:
explicit PoolWorker(QObject *parent = 0);
void run();
static QMutex mutex;
signals:
public slots:
private:
};
#endif // POOLWORKER_H
#include "poolworker.h"
QMutex PoolWorker::mutex;
PoolWorker::PoolWorker(QObject *parent) :
QThread(parent)
{
}
void PoolWorker::run()
{
Segment *temp;
forever
{
mutex.lock();
while(Pool::segmentQueue.isEmpty())
{
Pool::con.wait(&mutex);
}
temp = Pool::segmentQueue.dequeue();
mutex.unlock();
temp->doWork();
}
}
Each interval is put into a container "Segment" which also calculates the integral.
Sab = 0.5*(b-a)*(f(a)+f(b))
m = (a+b)/2.0
Sam = 0.5*(m-a)*(f(a)+f(m))
Smb = 0.5*(b-m)*(f(b)+f(m))
If the difference between Sab and Sam+Smb is lower than Eps, then I add Sab to the integral sum using Manager::addSum. If it's not lower, I do the same algorithm for am and mb. etc.
#ifndef SEGMENT_H
#define SEGMENT_H
#include <QObject>
#include <cmath>
#include "manager.h"
#include <QDebug>
class Segment : public QObject
{
Q_OBJECT
private:
double a,b,Sab,Sam,Smb,m,Eps;
double f(double x);
public:
explicit Segment(QObject *parent = 0);
Segment(double a, double b);
void doWork();
signals:
public slots:
};
#endif // SEGMENT_H
#include "segment.h"
Segment::Segment(QObject *parent) :
QObject(parent)
{
}
Segment::Segment(double a, double b)
{
this->a = a;
this->b = b;
Eps = 0.001;
}
void Segment::doWork()
{
Sab = 0.5*(b-a)*(f(a)+f(b));
m = (a+b)/2.0;
Sam = 0.5*(m-a)*(f(a)+f(m));
Smb = 0.5*(b-m)*(f(b)+f(m));
if (fabs(Sab - (Sam + Smb)) <= Eps)
{
Manager::addSum(Sab);
qDebug() << "Reached Eps on interval a= " << a << ",b = " << b
<< ", return S+= " << Sab;
Manager::inc();
}
else
{
Manager::threadPool->execute(new Segment(a,m));
Manager::threadPool->execute(new Segment(m,b));
}
}
double Segment::f(double x)
{
return pow(x,3.0) - 4.0*pow(x,2.0) + 6.0*x - 24.0;
}
The Manager class ties everything in: it creates the pool, contains the sum and starts the calculation by calling execute on pool with the first interval. It also has a counter for debugging purposes.
#ifndef MANAGER_H
#define MANAGER_H
#include <QObject>
#include <QThread>
#include <QQueue>
#include <QVector>
#include "segment.h"
#include "pool.h"
class Pool;
class Manager : public QObject
{
Q_OBJECT
private:
static double sum;
static int i;
static QMutex mutex;
public:
explicit Manager(QObject *parent = 0);
static Pool *threadPool;
static void addSum(double add);
static void inc();
double viewSum();
int viewCount();
void doSetup(QThread &thread);
signals:
public slots:
void doWork();
};
#endif // MANAGER_H
#include "manager.h"
double Manager::sum = 0;
int Manager::i = 0;
Pool* Manager::threadPool = new Pool(10);
QMutex Manager::mutex;
Manager::Manager(QObject *parent) :
QObject(parent)
{
}
void Manager::addSum(double add)
{
mutex.lock();
sum += add;
mutex.unlock();
}
void Manager::inc()
{
i++;
}
double Manager::viewSum()
{
return sum;
}
int Manager::viewCount()
{
return i;
}
void Manager::doSetup(QThread &thread)
{
connect(&thread,SIGNAL(started()),this,SLOT(doWork()));
}
void Manager::doWork()
{
threadPool->execute(new Segment(4.5,12.0));
}
In main I create the manager, a thread for the manager and display the results.
#include <QCoreApplication>
#include <QDebug>
#include <QThread>
#include <QTimer>
#include "manager.h"
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Manager man;
QThread manThread;
man.doSetup(manThread);
man.moveToThread(&manThread);
manThread.start();
manThread.wait(2500);
qDebug() << "integrate(x^3 - 4*x^2 + 6*x - 24) from 4.5 to 12.0 = "
<< man.viewSum();
qDebug() << "i =" << man.viewCount();
manThread.quit();
QTimer::singleShot(1000, &a, SLOT(quit()));
return a.exec();
}
It calculates the integral correctly about half of the time. The other half I get a larger number than expected(which varies). When I get a larger number, I notice that some of the intervals are calculated twice. If I'm not mistaken I have made the code thread-safe so I don't understand how this happens. I'm pretty new to multithread programming so I might be doing something wrong with mutexes? Or maybe my transition from the java pool is wrong?
Another thing is in main.cpp I'm not sure how to properly display the results since I don't know when the integral is done calculating. I am using a wait(2500) function on the thread that contains the manager but it's not a really good method since the calculation time may vary on different PC's and for different functions.
Thanks in advance for any help you are able to provide.

Answer 1

You got your locking wrong. In the Java example you pointed to, the same lock (the queue itself) is used in enqueueing (in execute) and dequeueing (in the worker threads). That way, the queue operations are really threadsafe. In your code unfortunately, you use two different locks. Pool::poolMutex for enque (in execute) and PoolWorker::mutex for deque (in the PoolWorker thread). That way, you guard the queue only for deque between threads, but deque and enque can happen concurrently. Your Pool::poolMutex is useless because execute is being called only by one thread, so it is being locked and unlocked only by one thread. You need to use only one and the same mutex for enque and deque. Pass the Pool::poolMutex into PoolWorker via constructor and lock on it instead of PoolWorker::mutex.
So when you enque and some thread has just finished working, it will deque immediately (because queue is not empty), not waiting for your wakeOne. Then on wakeOne, you will fire off another thread. I don't have a clear explanation of how the two threads can grab the same job (and not crash), but your code will definitely work better if you use only one lock as in the Java original.