#include "config.h"
#include "Threading.h"
#if !USE(PTHREADS)
#include "CurrentTime.h"
#include "HashMap.h"
#include "MainThread.h"
#include "RandomNumberSeed.h"
#include <glib.h>
#include <limits.h>
namespace WTF {
static Mutex* atomicallyInitializedStaticMutex;
static Mutex& threadMapMutex()
{
static Mutex mutex;
return mutex;
}
void initializeThreading()
{
if (!g_thread_supported())
g_thread_init(NULL);
ASSERT(g_thread_supported());
if (!atomicallyInitializedStaticMutex) {
atomicallyInitializedStaticMutex = new Mutex;
threadMapMutex();
initializeRandomNumberGenerator();
}
}
void lockAtomicallyInitializedStaticMutex()
{
ASSERT(atomicallyInitializedStaticMutex);
atomicallyInitializedStaticMutex->lock();
}
void unlockAtomicallyInitializedStaticMutex()
{
atomicallyInitializedStaticMutex->unlock();
}
static HashMap<ThreadIdentifier, GThread*>& threadMap()
{
static HashMap<ThreadIdentifier, GThread*> map;
return map;
}
static ThreadIdentifier identifierByGthreadHandle(GThread*& thread)
{
MutexLocker locker(threadMapMutex());
HashMap<ThreadIdentifier, GThread*>::iterator i = threadMap().begin();
for (; i != threadMap().end(); ++i) {
if (i->second == thread)
return i->first;
}
return 0;
}
static ThreadIdentifier establishIdentifierForThread(GThread*& thread)
{
ASSERT(!identifierByGthreadHandle(thread));
MutexLocker locker(threadMapMutex());
static ThreadIdentifier identifierCount = 1;
threadMap().add(identifierCount, thread);
return identifierCount++;
}
static GThread* threadForIdentifier(ThreadIdentifier id)
{
MutexLocker locker(threadMapMutex());
return threadMap().get(id);
}
static void clearThreadForIdentifier(ThreadIdentifier id)
{
MutexLocker locker(threadMapMutex());
ASSERT(threadMap().contains(id));
threadMap().remove(id);
}
ThreadIdentifier createThreadInternal(ThreadFunction entryPoint, void* data, const char*)
{
GThread* thread;
if (!(thread = g_thread_create(entryPoint, data, TRUE, 0))) {
LOG_ERROR("Failed to create thread at entry point %p with data %p", entryPoint, data);
return 0;
}
ThreadIdentifier threadID = establishIdentifierForThread(thread);
return threadID;
}
void initializeCurrentThreadInternal(const char*)
{
}
int waitForThreadCompletion(ThreadIdentifier threadID, void** result)
{
ASSERT(threadID);
GThread* thread = threadForIdentifier(threadID);
void* joinResult = g_thread_join(thread);
if (result)
*result = joinResult;
clearThreadForIdentifier(threadID);
return 0;
}
void detachThread(ThreadIdentifier)
{
}
ThreadIdentifier currentThread()
{
GThread* currentThread = g_thread_self();
if (ThreadIdentifier id = identifierByGthreadHandle(currentThread))
return id;
return establishIdentifierForThread(currentThread);
}
Mutex::Mutex()
: m_mutex(g_mutex_new())
{
}
Mutex::~Mutex()
{
}
void Mutex::lock()
{
g_mutex_lock(m_mutex.get());
}
bool Mutex::tryLock()
{
return g_mutex_trylock(m_mutex.get());
}
void Mutex::unlock()
{
g_mutex_unlock(m_mutex.get());
}
ThreadCondition::ThreadCondition()
: m_condition(g_cond_new())
{
}
ThreadCondition::~ThreadCondition()
{
}
void ThreadCondition::wait(Mutex& mutex)
{
g_cond_wait(m_condition.get(), mutex.impl().get());
}
bool ThreadCondition::timedWait(Mutex& mutex, double absoluteTime)
{
if (absoluteTime < currentTime())
return false;
if (absoluteTime > INT_MAX) {
wait(mutex);
return true;
}
int timeSeconds = static_cast<int>(absoluteTime);
int timeMicroseconds = static_cast<int>((absoluteTime - timeSeconds) * 1000000.0);
GTimeVal targetTime;
targetTime.tv_sec = timeSeconds;
targetTime.tv_usec = timeMicroseconds;
return g_cond_timed_wait(m_condition.get(), mutex.impl().get(), &targetTime);
}
void ThreadCondition::signal()
{
g_cond_signal(m_condition.get());
}
void ThreadCondition::broadcast()
{
g_cond_broadcast(m_condition.get());
}
}
#endif // !USE(PTHREADS)