ParallelJobsGeneric.h [plain text]
#ifndef ParallelJobsGeneric_h
#define ParallelJobsGeneric_h
#if ENABLE(THREADING_GENERIC)
#include <wtf/RefCounted.h>
#include <wtf/Threading.h>
namespace WTF {
class ParallelEnvironment {
WTF_MAKE_FAST_ALLOCATED;
public:
typedef void (*ThreadFunction)(void*);
ParallelEnvironment(ThreadFunction threadFunction, size_t sizeOfParameter, int requestedJobNumber) :
m_threadFunction(threadFunction),
m_sizeOfParameter(sizeOfParameter)
{
ASSERT_ARG(requestedJobNumber, requestedJobNumber >= 1);
if (s_maxNumberOfParallelThreads == -1)
determineMaxNumberOfParallelThreads();
if (!requestedJobNumber || requestedJobNumber > s_maxNumberOfParallelThreads)
requestedJobNumber = static_cast<unsigned>(s_maxNumberOfParallelThreads);
if (!s_threadPool)
s_threadPool = new Vector< RefPtr<ThreadPrivate> >();
int maxNumberOfNewThreads = requestedJobNumber - 1;
for (int i = 0; i < s_maxNumberOfParallelThreads && m_threads.size() < maxNumberOfNewThreads; ++i) {
if (s_threadPool->size() < i + 1)
s_threadPool->append(ThreadPrivate::create());
if ((*s_threadPool)[i]->tryLockFor(this))
m_threads.append((*s_threadPool)[i]);
}
m_numberOfJobs = m_threads.size() + 1;
}
int numberOfJobs()
{
return m_numberOfJobs;
}
void execute(unsigned char* parameters)
{
size_t i;
for (i = 0; i < m_threads.size(); ++i) {
m_threads[i]->execute(m_threadFunction, parameters);
parameters += m_sizeOfParameter;
}
(*m_threadFunction)(parameters);
for (i = 0; i < m_threads.size(); ++i)
m_threads[i]->waitForFinish();
}
class ThreadPrivate : public RefCounted<ThreadPrivate> {
public:
ThreadPrivate()
: m_threadID(0)
, m_running(false)
, m_parent(0)
{
}
bool tryLockFor(ParallelEnvironment*);
void execute(ThreadFunction, void*);
void waitForFinish();
static PassRefPtr<ThreadPrivate> create()
{
return adoptRef(new ThreadPrivate());
}
static void* workerThread(void*);
private:
ThreadIdentifier m_threadID;
bool m_running;
ParallelEnvironment* m_parent;
mutable Mutex m_mutex;
ThreadCondition m_threadCondition;
ThreadFunction m_threadFunction;
void* m_parameters;
};
private:
static void determineMaxNumberOfParallelThreads();
ThreadFunction m_threadFunction;
size_t m_sizeOfParameter;
int m_numberOfJobs;
Vector< RefPtr<ThreadPrivate> > m_threads;
static Vector< RefPtr<ThreadPrivate> >* s_threadPool;
static int s_maxNumberOfParallelThreads;
};
}
#endif // ENABLE(THREADING_GENERIC)
#endif // ParallelJobsGeneric_h