1127 lines
28 KiB
C++
1127 lines
28 KiB
C++
/*
|
|
* Copyright (C) 2007 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define LOG_TAG "libutils.threads"
|
|
|
|
#include <utils/threads.h>
|
|
#include <utils/Log.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <memory.h>
|
|
#include <errno.h>
|
|
#include <assert.h>
|
|
#include <unistd.h>
|
|
|
|
#if defined(HAVE_PTHREADS)
|
|
# include <pthread.h>
|
|
# include <sched.h>
|
|
# include <sys/resource.h>
|
|
#elif defined(HAVE_WIN32_THREADS)
|
|
# include <windows.h>
|
|
# include <stdint.h>
|
|
# include <process.h>
|
|
# define HAVE_CREATETHREAD // Cygwin, vs. HAVE__BEGINTHREADEX for MinGW
|
|
#endif
|
|
|
|
#if defined(HAVE_FUTEX)
|
|
#include <private/utils/futex_synchro.h>
|
|
#endif
|
|
|
|
#if defined(HAVE_PRCTL)
|
|
#include <sys/prctl.h>
|
|
#endif
|
|
|
|
/*
|
|
* ===========================================================================
|
|
* Thread wrappers
|
|
* ===========================================================================
|
|
*/
|
|
|
|
using namespace android;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if defined(HAVE_PTHREADS)
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark PTHREAD
|
|
#endif
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*
|
|
* Create and run a new thead.
|
|
*
|
|
* We create it "detached", so it cleans up after itself.
|
|
*/
|
|
|
|
typedef void* (*android_pthread_entry)(void*);
|
|
|
|
struct thread_data_t {
|
|
thread_func_t entryFunction;
|
|
void* userData;
|
|
int priority;
|
|
char * threadName;
|
|
|
|
// we use this trampoline when we need to set the priority with
|
|
// nice/setpriority.
|
|
static int trampoline(const thread_data_t* t) {
|
|
thread_func_t f = t->entryFunction;
|
|
void* u = t->userData;
|
|
int prio = t->priority;
|
|
char * name = t->threadName;
|
|
delete t;
|
|
setpriority(PRIO_PROCESS, 0, prio);
|
|
if (name) {
|
|
#if defined(HAVE_PRCTL)
|
|
// Mac OS doesn't have this, and we build libutil for the host too
|
|
int hasAt = 0;
|
|
int hasDot = 0;
|
|
char *s = name;
|
|
while (*s) {
|
|
if (*s == '.') hasDot = 1;
|
|
else if (*s == '@') hasAt = 1;
|
|
s++;
|
|
}
|
|
int len = s - name;
|
|
if (len < 15 || hasAt || !hasDot) {
|
|
s = name;
|
|
} else {
|
|
s = name + len - 15;
|
|
}
|
|
prctl(PR_SET_NAME, (unsigned long) s, 0, 0, 0);
|
|
#endif
|
|
free(name);
|
|
}
|
|
return f(u);
|
|
}
|
|
};
|
|
|
|
int androidCreateRawThreadEtc(android_thread_func_t entryFunction,
|
|
void *userData,
|
|
const char* threadName,
|
|
int32_t threadPriority,
|
|
size_t threadStackSize,
|
|
android_thread_id_t *threadId)
|
|
{
|
|
pthread_attr_t attr;
|
|
pthread_attr_init(&attr);
|
|
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
|
|
|
|
#ifdef HAVE_ANDROID_OS /* valgrind is rejecting RT-priority create reqs */
|
|
if (threadPriority != PRIORITY_DEFAULT || threadName != NULL) {
|
|
// We could avoid the trampoline if there was a way to get to the
|
|
// android_thread_id_t (pid) from pthread_t
|
|
thread_data_t* t = new thread_data_t;
|
|
t->priority = threadPriority;
|
|
t->threadName = threadName ? strdup(threadName) : NULL;
|
|
t->entryFunction = entryFunction;
|
|
t->userData = userData;
|
|
entryFunction = (android_thread_func_t)&thread_data_t::trampoline;
|
|
userData = t;
|
|
}
|
|
#endif
|
|
|
|
if (threadStackSize) {
|
|
pthread_attr_setstacksize(&attr, threadStackSize);
|
|
}
|
|
|
|
errno = 0;
|
|
pthread_t thread;
|
|
int result = pthread_create(&thread, &attr,
|
|
(android_pthread_entry)entryFunction, userData);
|
|
if (result != 0) {
|
|
LOGE("androidCreateRawThreadEtc failed (entry=%p, res=%d, errno=%d)\n"
|
|
"(android threadPriority=%d)",
|
|
entryFunction, result, errno, threadPriority);
|
|
return 0;
|
|
}
|
|
|
|
if (threadId != NULL) {
|
|
*threadId = (android_thread_id_t)thread; // XXX: this is not portable
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
android_thread_id_t androidGetThreadId()
|
|
{
|
|
return (android_thread_id_t)pthread_self();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#elif defined(HAVE_WIN32_THREADS)
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark WIN32_THREADS
|
|
#endif
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*
|
|
* Trampoline to make us __stdcall-compliant.
|
|
*
|
|
* We're expected to delete "vDetails" when we're done.
|
|
*/
|
|
struct threadDetails {
|
|
int (*func)(void*);
|
|
void* arg;
|
|
};
|
|
static __stdcall unsigned int threadIntermediary(void* vDetails)
|
|
{
|
|
struct threadDetails* pDetails = (struct threadDetails*) vDetails;
|
|
int result;
|
|
|
|
result = (*(pDetails->func))(pDetails->arg);
|
|
|
|
delete pDetails;
|
|
|
|
LOG(LOG_VERBOSE, "thread", "thread exiting\n");
|
|
return (unsigned int) result;
|
|
}
|
|
|
|
/*
|
|
* Create and run a new thread.
|
|
*/
|
|
static bool doCreateThread(android_thread_func_t fn, void* arg, android_thread_id_t *id)
|
|
{
|
|
HANDLE hThread;
|
|
struct threadDetails* pDetails = new threadDetails; // must be on heap
|
|
unsigned int thrdaddr;
|
|
|
|
pDetails->func = fn;
|
|
pDetails->arg = arg;
|
|
|
|
#if defined(HAVE__BEGINTHREADEX)
|
|
hThread = (HANDLE) _beginthreadex(NULL, 0, threadIntermediary, pDetails, 0,
|
|
&thrdaddr);
|
|
if (hThread == 0)
|
|
#elif defined(HAVE_CREATETHREAD)
|
|
hThread = CreateThread(NULL, 0,
|
|
(LPTHREAD_START_ROUTINE) threadIntermediary,
|
|
(void*) pDetails, 0, (DWORD*) &thrdaddr);
|
|
if (hThread == NULL)
|
|
#endif
|
|
{
|
|
LOG(LOG_WARN, "thread", "WARNING: thread create failed\n");
|
|
return false;
|
|
}
|
|
|
|
#if defined(HAVE_CREATETHREAD)
|
|
/* close the management handle */
|
|
CloseHandle(hThread);
|
|
#endif
|
|
|
|
if (id != NULL) {
|
|
*id = (android_thread_id_t)thrdaddr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int androidCreateRawThreadEtc(android_thread_func_t fn,
|
|
void *userData,
|
|
const char* threadName,
|
|
int32_t threadPriority,
|
|
size_t threadStackSize,
|
|
android_thread_id_t *threadId)
|
|
{
|
|
return doCreateThread( fn, userData, threadId);
|
|
}
|
|
|
|
android_thread_id_t androidGetThreadId()
|
|
{
|
|
return (android_thread_id_t)GetCurrentThreadId();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#else
|
|
#error "Threads not supported"
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Common Thread functions
|
|
#endif
|
|
|
|
int androidCreateThread(android_thread_func_t fn, void* arg)
|
|
{
|
|
return createThreadEtc(fn, arg);
|
|
}
|
|
|
|
int androidCreateThreadGetID(android_thread_func_t fn, void *arg, android_thread_id_t *id)
|
|
{
|
|
return createThreadEtc(fn, arg, "android:unnamed_thread",
|
|
PRIORITY_DEFAULT, 0, id);
|
|
}
|
|
|
|
static android_create_thread_fn gCreateThreadFn = androidCreateRawThreadEtc;
|
|
|
|
int androidCreateThreadEtc(android_thread_func_t entryFunction,
|
|
void *userData,
|
|
const char* threadName,
|
|
int32_t threadPriority,
|
|
size_t threadStackSize,
|
|
android_thread_id_t *threadId)
|
|
{
|
|
return gCreateThreadFn(entryFunction, userData, threadName,
|
|
threadPriority, threadStackSize, threadId);
|
|
}
|
|
|
|
void androidSetCreateThreadFunc(android_create_thread_fn func)
|
|
{
|
|
gCreateThreadFn = func;
|
|
}
|
|
|
|
namespace android {
|
|
|
|
/*
|
|
* ===========================================================================
|
|
* Mutex class
|
|
* ===========================================================================
|
|
*/
|
|
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Mutex
|
|
#endif
|
|
|
|
#if defined(HAVE_PTHREADS) && !defined(HAVE_FUTEX)
|
|
/*
|
|
* Simple pthread wrapper.
|
|
*/
|
|
|
|
Mutex::Mutex()
|
|
{
|
|
_init();
|
|
}
|
|
|
|
Mutex::Mutex(const char* name)
|
|
{
|
|
// XXX: name not used for now
|
|
_init();
|
|
}
|
|
|
|
void Mutex::_init()
|
|
{
|
|
pthread_mutex_t* pMutex = new pthread_mutex_t;
|
|
pthread_mutex_init(pMutex, NULL);
|
|
mState = pMutex;
|
|
}
|
|
|
|
Mutex::~Mutex()
|
|
{
|
|
delete (pthread_mutex_t*) mState;
|
|
}
|
|
|
|
status_t Mutex::lock()
|
|
{
|
|
int res;
|
|
while ((res=pthread_mutex_lock((pthread_mutex_t*) mState)) == EINTR) ;
|
|
return -res;
|
|
}
|
|
|
|
void Mutex::unlock()
|
|
{
|
|
pthread_mutex_unlock((pthread_mutex_t*) mState);
|
|
}
|
|
|
|
status_t Mutex::tryLock()
|
|
{
|
|
int res;
|
|
while ((res=pthread_mutex_trylock((pthread_mutex_t*) mState)) == EINTR) ;
|
|
return -res;
|
|
}
|
|
|
|
#elif defined(HAVE_FUTEX)
|
|
#if 0
|
|
#pragma mark -
|
|
#endif
|
|
|
|
#define STATE ((futex_mutex_t*) (&mState))
|
|
|
|
Mutex::Mutex()
|
|
{
|
|
_init();
|
|
}
|
|
|
|
Mutex::Mutex(const char* name)
|
|
{
|
|
_init();
|
|
}
|
|
|
|
void
|
|
Mutex::_init()
|
|
{
|
|
futex_mutex_init(STATE);
|
|
}
|
|
|
|
Mutex::~Mutex()
|
|
{
|
|
}
|
|
|
|
status_t Mutex::lock()
|
|
{
|
|
int res;
|
|
while ((res=futex_mutex_lock(STATE, FUTEX_WAIT_INFINITE)) == EINTR) ;
|
|
return -res;
|
|
}
|
|
|
|
void Mutex::unlock()
|
|
{
|
|
futex_mutex_unlock(STATE);
|
|
}
|
|
|
|
status_t Mutex::tryLock()
|
|
{
|
|
int res;
|
|
while ((res=futex_mutex_trylock(STATE)) == EINTR) ;
|
|
return -res;
|
|
}
|
|
#undef STATE
|
|
|
|
#elif defined(HAVE_WIN32_THREADS)
|
|
#if 0
|
|
#pragma mark -
|
|
#endif
|
|
|
|
Mutex::Mutex()
|
|
{
|
|
HANDLE hMutex;
|
|
|
|
assert(sizeof(hMutex) == sizeof(mState));
|
|
|
|
hMutex = CreateMutex(NULL, FALSE, NULL);
|
|
mState = (void*) hMutex;
|
|
}
|
|
|
|
Mutex::Mutex(const char* name)
|
|
{
|
|
// XXX: name not used for now
|
|
HANDLE hMutex;
|
|
|
|
hMutex = CreateMutex(NULL, FALSE, NULL);
|
|
mState = (void*) hMutex;
|
|
}
|
|
|
|
Mutex::~Mutex()
|
|
{
|
|
CloseHandle((HANDLE) mState);
|
|
}
|
|
|
|
status_t Mutex::lock()
|
|
{
|
|
DWORD dwWaitResult;
|
|
dwWaitResult = WaitForSingleObject((HANDLE) mState, INFINITE);
|
|
return dwWaitResult != WAIT_OBJECT_0 ? -1 : NO_ERROR;
|
|
}
|
|
|
|
void Mutex::unlock()
|
|
{
|
|
if (!ReleaseMutex((HANDLE) mState))
|
|
LOG(LOG_WARN, "thread", "WARNING: bad result from unlocking mutex\n");
|
|
}
|
|
|
|
status_t Mutex::tryLock()
|
|
{
|
|
DWORD dwWaitResult;
|
|
|
|
dwWaitResult = WaitForSingleObject((HANDLE) mState, 0);
|
|
if (dwWaitResult != WAIT_OBJECT_0 && dwWaitResult != WAIT_TIMEOUT)
|
|
LOG(LOG_WARN, "thread", "WARNING: bad result from try-locking mutex\n");
|
|
return (dwWaitResult == WAIT_OBJECT_0) ? 0 : -1;
|
|
}
|
|
|
|
#else
|
|
#error "Somebody forgot to implement threads for this platform."
|
|
#endif
|
|
|
|
|
|
/*
|
|
* ===========================================================================
|
|
* Condition class
|
|
* ===========================================================================
|
|
*/
|
|
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Condition
|
|
#endif
|
|
|
|
#if defined(HAVE_PTHREADS) && !defined(HAVE_FUTEX)
|
|
|
|
/*
|
|
* Constructor. This is a simple pthread wrapper.
|
|
*/
|
|
Condition::Condition()
|
|
{
|
|
pthread_cond_t* pCond = new pthread_cond_t;
|
|
|
|
pthread_cond_init(pCond, NULL);
|
|
mState = pCond;
|
|
}
|
|
|
|
/*
|
|
* Destructor.
|
|
*/
|
|
Condition::~Condition()
|
|
{
|
|
pthread_cond_destroy((pthread_cond_t*) mState);
|
|
delete (pthread_cond_t*) mState;
|
|
}
|
|
|
|
/*
|
|
* Wait on a condition variable. Lock the mutex before calling.
|
|
*/
|
|
|
|
status_t Condition::wait(Mutex& mutex)
|
|
{
|
|
assert(mutex.mState != NULL);
|
|
|
|
int cc;
|
|
while ((cc = pthread_cond_wait((pthread_cond_t*)mState,
|
|
(pthread_mutex_t*) mutex.mState)) == EINTR) ;
|
|
return -cc;
|
|
}
|
|
|
|
status_t Condition::wait(Mutex& mutex, nsecs_t abstime)
|
|
{
|
|
assert(mutex.mState != NULL);
|
|
|
|
struct timespec ts;
|
|
ts.tv_sec = abstime/1000000000;
|
|
ts.tv_nsec = abstime-(ts.tv_sec*1000000000);
|
|
|
|
int cc;
|
|
while ((cc = pthread_cond_timedwait((pthread_cond_t*)mState,
|
|
(pthread_mutex_t*) mutex.mState, &ts)) == EINTR) ;
|
|
return -cc;
|
|
}
|
|
|
|
status_t Condition::waitRelative(Mutex& mutex, nsecs_t reltime)
|
|
{
|
|
return wait(mutex, systemTime()+reltime);
|
|
}
|
|
|
|
/*
|
|
* Signal the condition variable, allowing one thread to continue.
|
|
*/
|
|
void Condition::signal()
|
|
{
|
|
pthread_cond_signal((pthread_cond_t*) mState);
|
|
}
|
|
|
|
/*
|
|
* Signal the condition variable, allowing all threads to continue.
|
|
*/
|
|
void Condition::broadcast()
|
|
{
|
|
pthread_cond_broadcast((pthread_cond_t*) mState);
|
|
}
|
|
|
|
#elif defined(HAVE_FUTEX)
|
|
#if 0
|
|
#pragma mark -
|
|
#endif
|
|
|
|
#define STATE ((futex_cond_t*) (&mState))
|
|
|
|
/*
|
|
* Constructor. This is a simple pthread wrapper.
|
|
*/
|
|
Condition::Condition()
|
|
{
|
|
futex_cond_init(STATE);
|
|
}
|
|
|
|
/*
|
|
* Destructor.
|
|
*/
|
|
Condition::~Condition()
|
|
{
|
|
}
|
|
|
|
/*
|
|
* Wait on a condition variable. Lock the mutex before calling.
|
|
*/
|
|
|
|
status_t Condition::wait(Mutex& mutex)
|
|
{
|
|
assert(mutex.mState != NULL);
|
|
|
|
int res;
|
|
while ((res = futex_cond_wait(STATE,
|
|
(futex_mutex_t*)(&mutex.mState), FUTEX_WAIT_INFINITE)) == -EINTR) ;
|
|
|
|
return -res;
|
|
}
|
|
|
|
status_t Condition::wait(Mutex& mutex, nsecs_t abstime)
|
|
{
|
|
nsecs_t reltime = abstime - systemTime();
|
|
if (reltime <= 0) return true;
|
|
return waitRelative(mutex, reltime);
|
|
}
|
|
|
|
status_t Condition::waitRelative(Mutex& mutex, nsecs_t reltime)
|
|
{
|
|
assert(mutex.mState != NULL);
|
|
int res;
|
|
unsigned msec = ns2ms(reltime);
|
|
if(msec == 0)
|
|
return true;
|
|
// This code will not time out at the correct time if interrupted by signals
|
|
while ((res = futex_cond_wait(STATE,
|
|
(futex_mutex_t*)(&mutex.mState), msec)) == -EINTR) ;
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
* Signal the condition variable, allowing one thread to continue.
|
|
*/
|
|
void Condition::signal()
|
|
{
|
|
futex_cond_signal(STATE);
|
|
}
|
|
|
|
/*
|
|
* Signal the condition variable, allowing all threads to continue.
|
|
*/
|
|
void Condition::broadcast()
|
|
{
|
|
futex_cond_broadcast(STATE);
|
|
}
|
|
|
|
#undef STATE
|
|
|
|
#elif defined(HAVE_WIN32_THREADS)
|
|
#if 0
|
|
#pragma mark -
|
|
#endif
|
|
|
|
/*
|
|
* Windows doesn't have a condition variable solution. It's possible
|
|
* to create one, but it's easy to get it wrong. For a discussion, and
|
|
* the origin of this implementation, see:
|
|
*
|
|
* http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
|
|
*
|
|
* The implementation shown on the page does NOT follow POSIX semantics.
|
|
* As an optimization they require acquiring the external mutex before
|
|
* calling signal() and broadcast(), whereas POSIX only requires grabbing
|
|
* it before calling wait(). The implementation here has been un-optimized
|
|
* to have the correct behavior.
|
|
*/
|
|
typedef struct WinCondition {
|
|
// Number of waiting threads.
|
|
int waitersCount;
|
|
|
|
// Serialize access to waitersCount.
|
|
CRITICAL_SECTION waitersCountLock;
|
|
|
|
// Semaphore used to queue up threads waiting for the condition to
|
|
// become signaled.
|
|
HANDLE sema;
|
|
|
|
// An auto-reset event used by the broadcast/signal thread to wait
|
|
// for all the waiting thread(s) to wake up and be released from
|
|
// the semaphore.
|
|
HANDLE waitersDone;
|
|
|
|
// This mutex wouldn't be necessary if we required that the caller
|
|
// lock the external mutex before calling signal() and broadcast().
|
|
// I'm trying to mimic pthread semantics though.
|
|
HANDLE internalMutex;
|
|
|
|
// Keeps track of whether we were broadcasting or signaling. This
|
|
// allows us to optimize the code if we're just signaling.
|
|
bool wasBroadcast;
|
|
|
|
status_t wait(WinCondition* condState, HANDLE hMutex, nsecs_t* abstime)
|
|
{
|
|
// Increment the wait count, avoiding race conditions.
|
|
EnterCriticalSection(&condState->waitersCountLock);
|
|
condState->waitersCount++;
|
|
//printf("+++ wait: incr waitersCount to %d (tid=%ld)\n",
|
|
// condState->waitersCount, getThreadId());
|
|
LeaveCriticalSection(&condState->waitersCountLock);
|
|
|
|
DWORD timeout = INFINITE;
|
|
if (abstime) {
|
|
nsecs_t reltime = *abstime - systemTime();
|
|
if (reltime < 0)
|
|
reltime = 0;
|
|
timeout = reltime/1000000;
|
|
}
|
|
|
|
// Atomically release the external mutex and wait on the semaphore.
|
|
DWORD res =
|
|
SignalObjectAndWait(hMutex, condState->sema, timeout, FALSE);
|
|
|
|
//printf("+++ wait: awake (tid=%ld)\n", getThreadId());
|
|
|
|
// Reacquire lock to avoid race conditions.
|
|
EnterCriticalSection(&condState->waitersCountLock);
|
|
|
|
// No longer waiting.
|
|
condState->waitersCount--;
|
|
|
|
// Check to see if we're the last waiter after a broadcast.
|
|
bool lastWaiter = (condState->wasBroadcast && condState->waitersCount == 0);
|
|
|
|
//printf("+++ wait: lastWaiter=%d (wasBc=%d wc=%d)\n",
|
|
// lastWaiter, condState->wasBroadcast, condState->waitersCount);
|
|
|
|
LeaveCriticalSection(&condState->waitersCountLock);
|
|
|
|
// If we're the last waiter thread during this particular broadcast
|
|
// then signal broadcast() that we're all awake. It'll drop the
|
|
// internal mutex.
|
|
if (lastWaiter) {
|
|
// Atomically signal the "waitersDone" event and wait until we
|
|
// can acquire the internal mutex. We want to do this in one step
|
|
// because it ensures that everybody is in the mutex FIFO before
|
|
// any thread has a chance to run. Without it, another thread
|
|
// could wake up, do work, and hop back in ahead of us.
|
|
SignalObjectAndWait(condState->waitersDone, condState->internalMutex,
|
|
INFINITE, FALSE);
|
|
} else {
|
|
// Grab the internal mutex.
|
|
WaitForSingleObject(condState->internalMutex, INFINITE);
|
|
}
|
|
|
|
// Release the internal and grab the external.
|
|
ReleaseMutex(condState->internalMutex);
|
|
WaitForSingleObject(hMutex, INFINITE);
|
|
|
|
return res == WAIT_OBJECT_0 ? NO_ERROR : -1;
|
|
}
|
|
} WinCondition;
|
|
|
|
/*
|
|
* Constructor. Set up the WinCondition stuff.
|
|
*/
|
|
Condition::Condition()
|
|
{
|
|
WinCondition* condState = new WinCondition;
|
|
|
|
condState->waitersCount = 0;
|
|
condState->wasBroadcast = false;
|
|
// semaphore: no security, initial value of 0
|
|
condState->sema = CreateSemaphore(NULL, 0, 0x7fffffff, NULL);
|
|
InitializeCriticalSection(&condState->waitersCountLock);
|
|
// auto-reset event, not signaled initially
|
|
condState->waitersDone = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
// used so we don't have to lock external mutex on signal/broadcast
|
|
condState->internalMutex = CreateMutex(NULL, FALSE, NULL);
|
|
|
|
mState = condState;
|
|
}
|
|
|
|
/*
|
|
* Destructor. Free Windows resources as well as our allocated storage.
|
|
*/
|
|
Condition::~Condition()
|
|
{
|
|
WinCondition* condState = (WinCondition*) mState;
|
|
if (condState != NULL) {
|
|
CloseHandle(condState->sema);
|
|
CloseHandle(condState->waitersDone);
|
|
delete condState;
|
|
}
|
|
}
|
|
|
|
|
|
status_t Condition::wait(Mutex& mutex)
|
|
{
|
|
WinCondition* condState = (WinCondition*) mState;
|
|
HANDLE hMutex = (HANDLE) mutex.mState;
|
|
|
|
return ((WinCondition*)mState)->wait(condState, hMutex, NULL);
|
|
}
|
|
|
|
status_t Condition::wait(Mutex& mutex, nsecs_t abstime)
|
|
{
|
|
WinCondition* condState = (WinCondition*) mState;
|
|
HANDLE hMutex = (HANDLE) mutex.mState;
|
|
|
|
return ((WinCondition*)mState)->wait(condState, hMutex, &abstime);
|
|
}
|
|
|
|
status_t Condition::waitRelative(Mutex& mutex, nsecs_t reltime)
|
|
{
|
|
return wait(mutex, systemTime()+reltime);
|
|
}
|
|
|
|
/*
|
|
* Signal the condition variable, allowing one thread to continue.
|
|
*/
|
|
void Condition::signal()
|
|
{
|
|
WinCondition* condState = (WinCondition*) mState;
|
|
|
|
// Lock the internal mutex. This ensures that we don't clash with
|
|
// broadcast().
|
|
WaitForSingleObject(condState->internalMutex, INFINITE);
|
|
|
|
EnterCriticalSection(&condState->waitersCountLock);
|
|
bool haveWaiters = (condState->waitersCount > 0);
|
|
LeaveCriticalSection(&condState->waitersCountLock);
|
|
|
|
// If no waiters, then this is a no-op. Otherwise, knock the semaphore
|
|
// down a notch.
|
|
if (haveWaiters)
|
|
ReleaseSemaphore(condState->sema, 1, 0);
|
|
|
|
// Release internal mutex.
|
|
ReleaseMutex(condState->internalMutex);
|
|
}
|
|
|
|
/*
|
|
* Signal the condition variable, allowing all threads to continue.
|
|
*
|
|
* First we have to wake up all threads waiting on the semaphore, then
|
|
* we wait until all of the threads have actually been woken before
|
|
* releasing the internal mutex. This ensures that all threads are woken.
|
|
*/
|
|
void Condition::broadcast()
|
|
{
|
|
WinCondition* condState = (WinCondition*) mState;
|
|
|
|
// Lock the internal mutex. This keeps the guys we're waking up
|
|
// from getting too far.
|
|
WaitForSingleObject(condState->internalMutex, INFINITE);
|
|
|
|
EnterCriticalSection(&condState->waitersCountLock);
|
|
bool haveWaiters = false;
|
|
|
|
if (condState->waitersCount > 0) {
|
|
haveWaiters = true;
|
|
condState->wasBroadcast = true;
|
|
}
|
|
|
|
if (haveWaiters) {
|
|
// Wake up all the waiters.
|
|
ReleaseSemaphore(condState->sema, condState->waitersCount, 0);
|
|
|
|
LeaveCriticalSection(&condState->waitersCountLock);
|
|
|
|
// Wait for all awakened threads to acquire the counting semaphore.
|
|
// The last guy who was waiting sets this.
|
|
WaitForSingleObject(condState->waitersDone, INFINITE);
|
|
|
|
// Reset wasBroadcast. (No crit section needed because nobody
|
|
// else can wake up to poke at it.)
|
|
condState->wasBroadcast = 0;
|
|
} else {
|
|
// nothing to do
|
|
LeaveCriticalSection(&condState->waitersCountLock);
|
|
}
|
|
|
|
// Release internal mutex.
|
|
ReleaseMutex(condState->internalMutex);
|
|
}
|
|
|
|
#else
|
|
#error "condition variables not supported on this platform"
|
|
#endif
|
|
|
|
|
|
/*
|
|
* ===========================================================================
|
|
* ReadWriteLock class
|
|
* ===========================================================================
|
|
*/
|
|
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark ReadWriteLock
|
|
#endif
|
|
|
|
/*
|
|
* Add a reader. Readers are nice. They share.
|
|
*/
|
|
void ReadWriteLock::lockForRead()
|
|
{
|
|
mLock.lock();
|
|
while (mNumWriters > 0) {
|
|
LOG(LOG_DEBUG, "thread", "+++ lockForRead: waiting\n");
|
|
mReadWaiter.wait(mLock);
|
|
}
|
|
assert(mNumWriters == 0);
|
|
mNumReaders++;
|
|
#if defined(PRINT_RENDER_TIMES)
|
|
if (mNumReaders == 1)
|
|
mDebugTimer.start();
|
|
#endif
|
|
mLock.unlock();
|
|
}
|
|
|
|
/*
|
|
* Try to add a reader. If it doesn't work right away, return "false".
|
|
*/
|
|
bool ReadWriteLock::tryLockForRead()
|
|
{
|
|
mLock.lock();
|
|
if (mNumWriters > 0) {
|
|
mLock.unlock();
|
|
return false;
|
|
}
|
|
assert(mNumWriters == 0);
|
|
mNumReaders++;
|
|
#if defined(PRINT_RENDER_TIMES)
|
|
if (mNumReaders == 1)
|
|
mDebugTimer.start();
|
|
#endif
|
|
mLock.unlock();
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Remove a reader.
|
|
*/
|
|
void ReadWriteLock::unlockForRead()
|
|
{
|
|
mLock.lock();
|
|
if (mNumReaders == 0) {
|
|
LOG(LOG_WARN, "thread",
|
|
"WARNING: unlockForRead requested, but not locked\n");
|
|
return;
|
|
}
|
|
assert(mNumReaders > 0);
|
|
assert(mNumWriters == 0);
|
|
mNumReaders--;
|
|
if (mNumReaders == 0) { // last reader?
|
|
#if defined(PRINT_RENDER_TIMES)
|
|
mDebugTimer.stop();
|
|
printf(" rdlk held %.3f msec\n",
|
|
(double) mDebugTimer.durationUsecs() / 1000.0);
|
|
#endif
|
|
//printf("+++ signaling writers (if any)\n");
|
|
mWriteWaiter.signal(); // wake one writer (if any)
|
|
}
|
|
mLock.unlock();
|
|
}
|
|
|
|
/*
|
|
* Add a writer. This requires exclusive access to the object.
|
|
*/
|
|
void ReadWriteLock::lockForWrite()
|
|
{
|
|
mLock.lock();
|
|
while (mNumReaders > 0 || mNumWriters > 0) {
|
|
LOG(LOG_DEBUG, "thread", "+++ lockForWrite: waiting\n");
|
|
mWriteWaiter.wait(mLock);
|
|
}
|
|
assert(mNumReaders == 0);
|
|
assert(mNumWriters == 0);
|
|
mNumWriters++;
|
|
#if defined(PRINT_RENDER_TIMES)
|
|
mDebugTimer.start();
|
|
#endif
|
|
mLock.unlock();
|
|
}
|
|
|
|
/*
|
|
* Try to add a writer. If it doesn't work right away, return "false".
|
|
*/
|
|
bool ReadWriteLock::tryLockForWrite()
|
|
{
|
|
mLock.lock();
|
|
if (mNumReaders > 0 || mNumWriters > 0) {
|
|
mLock.unlock();
|
|
return false;
|
|
}
|
|
assert(mNumReaders == 0);
|
|
assert(mNumWriters == 0);
|
|
mNumWriters++;
|
|
#if defined(PRINT_RENDER_TIMES)
|
|
mDebugTimer.start();
|
|
#endif
|
|
mLock.unlock();
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Remove a writer.
|
|
*/
|
|
void ReadWriteLock::unlockForWrite()
|
|
{
|
|
mLock.lock();
|
|
if (mNumWriters == 0) {
|
|
LOG(LOG_WARN, "thread",
|
|
"WARNING: unlockForWrite requested, but not locked\n");
|
|
return;
|
|
}
|
|
assert(mNumWriters == 1);
|
|
mNumWriters--;
|
|
#if defined(PRINT_RENDER_TIMES)
|
|
mDebugTimer.stop();
|
|
//printf(" wrlk held %.3f msec\n",
|
|
// (double) mDebugTimer.durationUsecs() / 1000.0);
|
|
#endif
|
|
// mWriteWaiter.signal(); // should other writers get first dibs?
|
|
//printf("+++ signaling readers (if any)\n");
|
|
mReadWaiter.broadcast(); // wake all readers (if any)
|
|
mLock.unlock();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#if 0
|
|
#pragma mark -
|
|
#pragma mark Thread::Thread
|
|
#endif
|
|
|
|
/*
|
|
* This is our thread object!
|
|
*/
|
|
|
|
Thread::Thread(bool canCallJava)
|
|
: mCanCallJava(canCallJava),
|
|
mThread(thread_id_t(-1)),
|
|
mLock("Thread::mLock"),
|
|
mStatus(NO_ERROR),
|
|
mExitPending(false), mRunning(false)
|
|
{
|
|
}
|
|
|
|
Thread::~Thread()
|
|
{
|
|
}
|
|
|
|
status_t Thread::readyToRun()
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t Thread::run(const char* name, int32_t priority, size_t stack)
|
|
{
|
|
Mutex::Autolock _l(mLock);
|
|
|
|
if (mRunning) {
|
|
// thread already started
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
// reset status and exitPending to their default value, so we can
|
|
// try again after an error happened (either below, or in readyToRun())
|
|
mStatus = NO_ERROR;
|
|
mExitPending = false;
|
|
mThread = thread_id_t(-1);
|
|
|
|
// hold a strong reference on ourself
|
|
mHoldSelf = this;
|
|
|
|
bool res;
|
|
if (mCanCallJava) {
|
|
res = createThreadEtc(_threadLoop,
|
|
this, name, priority, stack, &mThread);
|
|
} else {
|
|
res = androidCreateRawThreadEtc(_threadLoop,
|
|
this, name, priority, stack, &mThread);
|
|
}
|
|
|
|
if (res == false) {
|
|
mStatus = UNKNOWN_ERROR; // something happened!
|
|
mRunning = false;
|
|
mThread = thread_id_t(-1);
|
|
}
|
|
|
|
if (mStatus < 0) {
|
|
// something happened, don't leak
|
|
mHoldSelf.clear();
|
|
}
|
|
|
|
return mStatus;
|
|
}
|
|
|
|
int Thread::_threadLoop(void* user)
|
|
{
|
|
Thread* const self = static_cast<Thread*>(user);
|
|
sp<Thread> strong(self->mHoldSelf);
|
|
wp<Thread> weak(strong);
|
|
self->mHoldSelf.clear();
|
|
|
|
// we're about to run...
|
|
self->mStatus = self->readyToRun();
|
|
if (self->mStatus!=NO_ERROR || self->mExitPending) {
|
|
// pretend the thread never started...
|
|
self->mExitPending = false;
|
|
self->mRunning = false;
|
|
return 0;
|
|
}
|
|
|
|
// thread is running now
|
|
self->mRunning = true;
|
|
|
|
do {
|
|
bool result = self->threadLoop();
|
|
if (result == false || self->mExitPending) {
|
|
self->mExitPending = true;
|
|
self->mLock.lock();
|
|
self->mRunning = false;
|
|
self->mThreadExitedCondition.signal();
|
|
self->mLock.unlock();
|
|
break;
|
|
}
|
|
|
|
// Release our strong reference, to let a chance to the thread
|
|
// to die a peaceful death.
|
|
strong.clear();
|
|
// And immediately, reacquire a strong reference for the next loop
|
|
strong = weak.promote();
|
|
} while(strong != 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void Thread::requestExit()
|
|
{
|
|
mExitPending = true;
|
|
}
|
|
|
|
status_t Thread::requestExitAndWait()
|
|
{
|
|
if (mStatus == OK) {
|
|
|
|
if (mThread == getThreadId()) {
|
|
LOGW(
|
|
"Thread (this=%p): don't call waitForExit() from this "
|
|
"Thread object's thread. It's a guaranteed deadlock!",
|
|
this);
|
|
return WOULD_BLOCK;
|
|
}
|
|
|
|
requestExit();
|
|
|
|
Mutex::Autolock _l(mLock);
|
|
while (mRunning == true) {
|
|
mThreadExitedCondition.wait(mLock);
|
|
}
|
|
mExitPending = false;
|
|
}
|
|
return mStatus;
|
|
}
|
|
|
|
bool Thread::exitPending() const
|
|
{
|
|
return mExitPending;
|
|
}
|
|
|
|
|
|
|
|
}; // namespace android
|