// RCS-ID: $Id$
// Copyright: (c) Wolfram Gloger (1996, 1997)
// Guilhem Lavaux (1998)
-// Vadim Zeitlin (1999)
+// Vadim Zeitlin (1999-2002)
// Robert Roebling (1999)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include <pthread.h>
#include <errno.h>
#include <time.h>
-
#if HAVE_SCHED_H
#include <sched.h>
#endif
// our trace mask
#define TRACE_THREADS _T("thread")
+// ----------------------------------------------------------------------------
+// pseudo template types
+// ----------------------------------------------------------------------------
+
+WX_DECLARE_LIST(pthread_mutex_t, wxMutexList);
+
+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxMutexList);
+
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
#endif // wxUSE_GUI
// ============================================================================
-// implementation
+// wxMutex implementation
// ============================================================================
-//--------------------------------------------------------------------
-// wxMutex (Posix implementation)
-//--------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// wxMutexInternal
+// ----------------------------------------------------------------------------
class wxMutexInternal
{
public:
+ wxMutexInternal();
+ ~wxMutexInternal();
+
+ wxMutexError Lock();
+ wxMutexError TryLock();
+ wxMutexError Unlock();
+
+private:
pthread_mutex_t m_mutex;
};
-wxMutex::wxMutex()
+wxMutexInternal::wxMutexInternal()
{
- m_internal = new wxMutexInternal;
-
// support recursive locks like Win32, i.e. a thread can lock a mutex which
// it had itself already locked
+ //
+ // but initialization of recursive mutexes is non portable <sigh>, so try
+ // several methods
+#ifdef HAVE_PTHREAD_MUTEXATTR_T
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
- pthread_mutex_init(&(m_internal->m_mutex), &attr);
+
+ pthread_mutex_init(&m_mutex, &attr);
+#elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
+ // we can use this only as initializer so we have to assign it first to a
+ // temp var - assigning directly to m_mutex wouldn't even compile
+ pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+ m_mutex = mutex;
+#else // no recursive mutexes
+ pthread_mutex_init(&m_mutex, NULL);
+
+ // used by TryLock() below
+ #define NO_RECURSIVE_MUTEXES
+#endif // HAVE_PTHREAD_MUTEXATTR_T/...
+}
+
+wxMutexInternal::~wxMutexInternal()
+{
+ pthread_mutex_destroy(&m_mutex);
+}
+
+wxMutexError wxMutexInternal::Lock()
+{
+ int err = pthread_mutex_lock(&m_mutex);
+ switch ( err )
+ {
+ case EDEADLK:
+ wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+ return wxMUTEX_DEAD_LOCK;
+
+ default:
+ wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") );
+ // fall through
+
+ case EINVAL:
+ wxLogDebug(_T("Failed to lock the mutex."));
+ return wxMUTEX_MISC_ERROR;
+
+ case 0:
+ return wxMUTEX_NO_ERROR;
+ }
+}
+
+wxMutexError wxMutexInternal::TryLock()
+{
+ int err = pthread_mutex_trylock(&m_mutex);
+ switch ( err )
+ {
+ case EBUSY:
+ return wxMUTEX_BUSY;
+
+ default:
+ wxFAIL_MSG( _T("unexpected pthread_mutex_trylock() return") );
+ // fall through
+
+ case EINVAL:
+ wxLogDebug(_T("Failed to try to lock the mutex."));
+ return wxMUTEX_MISC_ERROR;
+
+ case 0:
+ return wxMUTEX_NO_ERROR;
+ }
+}
+
+wxMutexError wxMutexInternal::Unlock()
+{
+ int err = pthread_mutex_unlock(&m_mutex);
+ switch ( err )
+ {
+ case EPERM:
+ // we don't own the mutex
+ return wxMUTEX_UNLOCKED;
+
+ default:
+ wxFAIL_MSG( _T("unexpected pthread_mutex_unlock() return") );
+ // fall through
+
+ case EINVAL:
+ wxLogDebug(_T("Failed to unlock the mutex."));
+ return wxMUTEX_MISC_ERROR;
+
+ case 0:
+ return wxMUTEX_NO_ERROR;
+ }
+}
+
+// ----------------------------------------------------------------------------
+// wxMutex
+// ----------------------------------------------------------------------------
+
+// TODO: this is completely generic, move it to common code?
+
+wxMutex::wxMutex()
+{
+ m_internal = new wxMutexInternal;
m_locked = 0;
}
wxMutex::~wxMutex()
{
- if (m_locked > 0)
+ if ( m_locked > 0 )
wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
- pthread_mutex_destroy( &(m_internal->m_mutex) );
delete m_internal;
}
wxMutexError wxMutex::Lock()
{
- int err = pthread_mutex_lock( &(m_internal->m_mutex) );
- if (err == EDEADLK)
- {
- wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+ wxMutexError err = m_internal->Lock();
- return wxMUTEX_DEAD_LOCK;
+ if ( !err )
+ {
+ m_locked++;
}
- m_locked++;
-
- return wxMUTEX_NO_ERROR;
+ return err;
}
wxMutexError wxMutex::TryLock()
{
- if (m_locked)
+ if ( m_locked )
{
- return wxMUTEX_BUSY;
+#ifdef NO_RECURSIVE_MUTEXES
+ return wxMUTEX_DEAD_LOCK;
+#else // have recursive mutexes on this platform
+ // we will succeed in locking it when we have it already locked
+ return wxMUTEX_NO_ERROR;
+#endif // recursive/non-recursive mutexes
}
- int err = pthread_mutex_trylock( &(m_internal->m_mutex) );
- switch (err)
+ wxMutexError err = m_internal->TryLock();
+ if ( !err )
{
- case EBUSY: return wxMUTEX_BUSY;
+ m_locked++;
}
- m_locked++;
-
- return wxMUTEX_NO_ERROR;
+ return err;
}
wxMutexError wxMutex::Unlock()
{
- if (m_locked > 0)
+ if ( m_locked > 0 )
{
m_locked--;
}
return wxMUTEX_UNLOCKED;
}
- pthread_mutex_unlock( &(m_internal->m_mutex) );
-
- return wxMUTEX_NO_ERROR;
+ return m_internal->Unlock();
}
-//--------------------------------------------------------------------
-// wxCondition (Posix implementation)
-//--------------------------------------------------------------------
+// ============================================================================
+// wxCondition implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxConditionInternal
+// ----------------------------------------------------------------------------
// The native POSIX condition variables are dumb: if the condition is signaled
// before another thread starts to wait on it, the signal is lost and so this
// other thread will be never woken up. It's much more convenient to us to
// remember that the condition was signaled and to return from Wait()
// immediately in this case (this is more like Win32 automatic event objects)
-
class wxConditionInternal
{
public:
wxConditionInternal();
~wxConditionInternal();
- void Wait();
- bool WaitWithTimeout(const timespec* ts);
+ // wait with the given timeout or indefinitely if NULL
+ bool Wait(const timespec* ts = NULL);
- void Signal();
- void Broadcast();
-
- void WaitDone();
- bool ShouldWait();
- bool HasWaiters();
+ void Signal(bool all = FALSE);
private:
- bool m_wasSignaled; // TRUE if condition was signaled while
- // nobody waited for it
- size_t m_nWaiters; // TRUE if someone already waits for us
-
- pthread_mutex_t m_mutexProtect; // protects access to vars above
-
- pthread_mutex_t m_mutex; // the mutex used with the condition
- pthread_cond_t m_condition; // the condition itself
+ // the number of Signal() calls queued
+ //
+ // changed by Signal(), accessed by Wait()
+ //
+ // protected by m_mutexSignalCount
+ size_t m_nSignalsMissed;
+
+ // protects access to m_nSignalsMissed
+ pthread_mutex_t m_mutexSignalCount;
+
+ // serializes Broadcast() and/or Signal() calls
+ //
+ // TODO: I'm not sure if this is really needed but it shouldn't harm
+ // neither (except for efficiency condierations). However MSW doesn't
+ // do this so maybe we shouldn't do it here neither? (VZ)
+ pthread_mutex_t m_mutexSignal;
+
+ // a condition variable must be always used with a mutex and so we maintain
+ // a list of mutexes - one for each thread that calls Wait().
+ //
+ // access to this list must be protected by m_mutexListContents
+ wxMutexList m_mutexes;
+
+ // the condition itself
+ pthread_cond_t m_condition;
+
+ // protects all accesses to m_mutexes list
+ pthread_mutex_t m_mutexListContents;
};
wxConditionInternal::wxConditionInternal()
{
- m_wasSignaled = FALSE;
- m_nWaiters = 0;
+ m_nSignalsMissed = 0;
if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 )
{
wxFAIL_MSG( _T("pthread_cond_init() failed") );
}
- if ( pthread_mutex_init(&m_mutex, (pthread_mutexattr_t *)NULL) != 0 ||
- pthread_mutex_init(&m_mutexProtect, NULL) != 0 )
+ if ( pthread_mutex_init(&m_mutexSignalCount, NULL) != 0 ||
+ pthread_mutex_init(&m_mutexListContents, NULL) != 0 ||
+ pthread_mutex_init(&m_mutexSignal, NULL) != 0 )
{
// neither this
wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") );
}
-
- // initially the mutex is locked, so no thread can Signal() or Broadcast()
- // until another thread starts to Wait()
- if ( pthread_mutex_lock(&m_mutex) != 0 )
- {
- wxFAIL_MSG( _T("wxCondition: pthread_mutex_lock() failed") );
- }
}
wxConditionInternal::~wxConditionInternal()
"threads are probably still waiting on it?)"));
}
- if ( pthread_mutex_unlock( &m_mutex ) != 0 )
- {
- wxLogDebug(_T("wxCondition: failed to unlock the mutex"));
- }
+ // the list of waiters mutexes must be empty by now
+ wxASSERT_MSG( !m_mutexes.GetFirst(),
+ _T("deleting condition someone is still waiting on?") );
- if ( pthread_mutex_destroy( &m_mutex ) != 0 ||
- pthread_mutex_destroy( &m_mutexProtect ) != 0 )
+ if ( pthread_mutex_destroy( &m_mutexSignalCount ) != 0 ||
+ pthread_mutex_destroy( &m_mutexListContents ) != 0 ||
+ pthread_mutex_destroy( &m_mutexSignal ) != 0 )
{
wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
}
}
-void wxConditionInternal::WaitDone()
+bool wxConditionInternal::Wait(const timespec* ts)
{
- MutexLock lock(m_mutexProtect);
+ {
+ wxLogTrace(TRACE_THREADS,
+ _T("wxCondition(%08x)::Wait: about to lock missed signal counter"),
+ this);
- m_wasSignaled = FALSE;
- m_nWaiters--;
-}
+ MutexLock lock(m_mutexSignalCount);
-bool wxConditionInternal::ShouldWait()
-{
- MutexLock lock(m_mutexProtect);
+ if ( m_nSignalsMissed )
+ {
+ // the condition was signaled before we started to wait, just
+ // decrease the number of queued signals and return
+ m_nSignalsMissed--;
- if ( m_wasSignaled )
- {
- // the condition was signaled before we started to wait, reset the
- // flag and return
- m_wasSignaled = FALSE;
+ wxLogTrace(TRACE_THREADS,
+ _T("wxCondition(%08x)::Wait: not waiting at all, count = %u"),
+ this, m_nSignalsMissed);
- return FALSE;
+ return TRUE;
+ }
}
- // we start to wait for it
- m_nWaiters++;
-
- return TRUE;
-}
+ // we need to really wait, create a new mutex for this
+ pthread_mutex_t *mutex = new pthread_mutex_t;
+ if ( pthread_mutex_init(mutex, (pthread_mutexattr_t *)NULL) != 0 )
+ {
+ // not supposed to happen
+ wxFAIL_MSG( _T("pthread_mutex_init() failed when starting waiting") );
+ }
-bool wxConditionInternal::HasWaiters()
-{
- MutexLock lock(m_mutexProtect);
+ // lock the mutex before starting to wait on it
+ pthread_mutex_lock(mutex);
- if ( m_nWaiters )
+ // lock the list before modifying it
+ wxMutexList::Node *mutexNode;
{
- // someone waits for us, signal the condition normally
- return TRUE;
+ MutexLock lockList(m_mutexListContents);
+
+ mutexNode = m_mutexes.Append(mutex);
}
- // nobody waits for us and may be never will - so just remember that the
- // condition was signaled and don't do anything else
- m_wasSignaled = TRUE;
+ // calling wait function below unlocks the mutex and Signal() or
+ // Broadcast() will be able to continue to run now if they were
+ // blocking for it in the loop locking all mutexes)
+ wxLogTrace(TRACE_THREADS,
+ _T("wxCondition(%08x)::Wait(): starting to wait"), this);
+ int err = ts ? pthread_cond_timedwait(&m_condition, mutex, ts)
+ : pthread_cond_wait(&m_condition, mutex);
+ switch ( err )
+ {
+ case 0:
+ // condition was signaled
+ wxLogTrace(TRACE_THREADS,
+ _T("wxCondition(%08x)::Wait(): ok"), this);
+ break;
- return FALSE;
-}
+ default:
+ wxLogDebug(_T("unexpected pthread_cond_[timed]wait() return"));
+ // fall through
-void wxConditionInternal::Wait()
-{
- if ( ShouldWait() )
+ case ETIMEDOUT:
+ case EINTR:
+ // wait interrupted or timeout elapsed
+ wxLogTrace(TRACE_THREADS,
+ _T("wxCondition(%08x)::Wait(): timeout/intr"), this);
+ }
+
+ // delete the mutex we had used for waiting
{
- if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 )
- {
- // not supposed to ever happen
- wxFAIL_MSG( _T("pthread_cond_wait() failed") );
- }
+ MutexLock lock(m_mutexListContents);
+
+ pthread_mutex_t *m = mutexNode->GetData();
+ pthread_mutex_unlock(m);
+ pthread_mutex_destroy(m);
+ delete m;
+
+ m_mutexes.DeleteNode(mutexNode);
}
- WaitDone();
+ return err == 0;
}
-bool wxConditionInternal::WaitWithTimeout(const timespec* ts)
+void wxConditionInternal::Signal(bool all)
{
- bool ok;
+ // make sure that only one Signal() or Broadcast() is in progress
+ MutexLock lock(m_mutexSignal);
+
+ // this mutex has to be locked as well, so that during the entire Signal()
+ // call, no new Wait() is going to wreak havoc (it will block in the very
+ // beginning on this mutex instead)
+ MutexLock lockSignalCount(m_mutexSignalCount);
+
+ wxLogTrace(TRACE_THREADS,
+ _T("wxCondition(%08x)::Signal(): got signal count mutex"),
+ this);
- if ( ShouldWait() )
{
- switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) )
- {
- case 0:
- // condition signaled
- ok = TRUE;
- break;
+ MutexLock lockList(m_mutexListContents);
- default:
- wxLogDebug(_T("pthread_cond_timedwait() failed"));
+ if ( !m_mutexes.GetFirst() )
+ {
+ // nobody is waiting for us, just remember that the condition was
+ // signaled and don't do anything else for now
+ m_nSignalsMissed++;
- // fall through
+ wxLogTrace(TRACE_THREADS,
+ _T("wxCondition(%08x)::Signal(): no waiters, count = %u"),
+ this, m_nSignalsMissed);
- case ETIMEDOUT:
- case EINTR:
- // wait interrupted or timeout elapsed
- ok = FALSE;
+ return;
}
}
- else
+
+ wxLogTrace(TRACE_THREADS,
+ _T("wxCondition(%08x)::Signal(): acquiring all mutexes"), this);
+
+ // All mutexes on the list have to be locked. This means that execution of
+ // Signal() goes on as soon as all pending Wait() calls have called
+ // pthread_cond_wait() (where the mutex gets unlocked internally)
+ wxMutexList::Node *node;
+ for ( node = m_mutexes.GetFirst(); node; node = node->GetNext() )
{
- // the condition had already been signaled before
- ok = TRUE;
+ pthread_mutex_lock(node->GetData());
}
- WaitDone();
+ // now we can finally signal it
+ wxLogTrace(TRACE_THREADS, _T("wxCondition(%08x)::Signal(): preparing to %s"),
+ this, all ? _T("broadcast") : _T("signal"));
- return ok;
-}
-
-void wxConditionInternal::Signal()
-{
- if ( HasWaiters() )
+ int err = all ? pthread_cond_broadcast(&m_condition)
+ : pthread_cond_signal(&m_condition);
+ if ( err )
{
- MutexLock lock(m_mutex);
-
- if ( pthread_cond_signal( &m_condition ) != 0 )
- {
- // shouldn't ever happen
- wxFAIL_MSG(_T("pthread_cond_signal() failed"));
- }
+ // shouldn't ever happen
+ wxFAIL_MSG(_T("pthread_cond_{broadcast|signal}() failed"));
}
-}
-void wxConditionInternal::Broadcast()
-{
- if ( HasWaiters() )
+ // unlock all mutexes so that the threads blocking in their Wait()s could
+ // continue running
+ for ( node = m_mutexes.GetFirst(); node; node = node->GetNext() )
{
- MutexLock lock(m_mutex);
-
- if ( pthread_cond_broadcast( &m_condition ) != 0 )
- {
- // shouldn't ever happen
- wxFAIL_MSG(_T("pthread_cond_broadcast() failed"));
- }
+ pthread_mutex_unlock(node->GetData());
}
+
+ wxLogTrace(TRACE_THREADS,
+ _T("wxCondition(%08x)::Signal(): exiting"), this);
}
+// ----------------------------------------------------------------------------
+// wxCondition
+// ----------------------------------------------------------------------------
+
wxCondition::wxCondition()
{
m_internal = new wxConditionInternal;
void wxCondition::Wait()
{
- m_internal->Wait();
+ (void)m_internal->Wait();
}
bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
tspec.tv_sec = time(0L) + sec; // FIXME is time(0) correct here?
tspec.tv_nsec = nsec;
- return m_internal->WaitWithTimeout(&tspec);
+ return m_internal->Wait(&tspec);
}
void wxCondition::Signal()
void wxCondition::Broadcast()
{
- m_internal->Broadcast();
+ m_internal->Signal(TRUE /* all */);
}
-//--------------------------------------------------------------------
-// wxThread (Posix implementation)
-//--------------------------------------------------------------------
+// ============================================================================
+// wxThread implementation
+// ============================================================================
+
+// the thread callback functions must have the C linkage
+extern "C"
+{
+
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+ // thread exit function
+ void wxPthreadCleanup(void *ptr);
+#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+
+void *wxPthreadStart(void *ptr);
+
+} // extern "C"
+
+// ----------------------------------------------------------------------------
+// wxThreadInternal
+// ----------------------------------------------------------------------------
class wxThreadInternal
{
~wxThreadInternal();
// thread entry function
- static void *PthreadStart(void *ptr);
-
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
- // thread exit function
- static void PthreadCleanup(void *ptr);
-#endif
+ static void *PthreadStart(wxThread *thread);
// thread actions
// start the thread
// sometimes - tell the thread that it should do it
void Notify() { m_shouldBroadcast = TRUE; }
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+ // this is used by wxPthreadCleanup() only
+ static void Cleanup(wxThread *thread);
+#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+
private:
pthread_t m_threadId; // id of the thread
wxThreadState m_state; // see wxThreadState enum
// thread startup and exit functions
// ----------------------------------------------------------------------------
-void *wxThreadInternal::PthreadStart(void *ptr)
+void *wxPthreadStart(void *ptr)
+{
+ return wxThreadInternal::PthreadStart((wxThread *)ptr);
+}
+
+void *wxThreadInternal::PthreadStart(wxThread *thread)
{
- wxThread *thread = (wxThread *)ptr;
wxThreadInternal *pthread = thread->m_internal;
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId());
+
// associate the thread pointer with the newly created thread so that
// wxThread::This() will work
int rc = pthread_setspecific(gs_keySelf, thread);
#if HAVE_THREAD_CLEANUP_FUNCTIONS
// install the cleanup handler which will be called if the thread is
// cancelled
- pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
+ pthread_cleanup_push(wxPthreadCleanup, thread);
#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
// wait for the condition to be signaled from Run()
pthread->GetId());
// change the state of the thread to "exited" so that
- // PthreadCleanup handler won't do anything from now (if it's
+ // wxPthreadCleanup handler won't do anything from now (if it's
// called before we do pthread_cleanup_pop below)
pthread->SetState(STATE_EXITED);
}
#if HAVE_THREAD_CLEANUP_FUNCTIONS
// this handler is called when the thread is cancelled
-void wxThreadInternal::PthreadCleanup(void *ptr)
+extern "C" void wxPthreadCleanup(void *ptr)
{
- wxThread *thread = (wxThread *) ptr;
+ wxThreadInternal::Cleanup((wxThread *)ptr);
+}
+void wxThreadInternal::Cleanup(wxThread *thread)
+{
{
wxCriticalSectionLocker lock(thread->m_critsect);
if ( thread->m_internal->GetState() == STATE_EXITED )
wxMutexGuiLeave();
bool isDetached = m_isDetached;
- long id = (long)GetId();
- wxLogTrace(TRACE_THREADS, _T("Starting to wait for thread %ld to exit."),
- id);
+ wxThreadIdType id = GetId();
+
+ wxLogTrace(TRACE_THREADS,
+ _T("Starting to wait for thread %ld to exit."), id);
// wait until the thread terminates (we're blocking in _another_ thread,
// of course)
int wxThread::GetCPUCount()
{
-#if defined(__LINUX__)
+#if defined(__LINUX__) && wxUSE_FFILE
// read from proc (can't use wxTextFile here because it's a special file:
// it has 0 size but still can be read from)
wxLogNull nolog;
return -1;
}
+#ifdef __VMS
+ // VMS is a 64 bit system and threads have 64 bit pointers.
+ // ??? also needed for other systems????
+unsigned long long wxThread::GetCurrentId()
+{
+ return (unsigned long long)pthread_self();
+#else
+unsigned long wxThread::GetCurrentId()
+{
+ return (unsigned long)pthread_self();
+#endif
+}
+
bool wxThread::SetConcurrency(size_t level)
{
#ifdef HAVE_THR_SETCONCURRENCY
m_isDetached = kind == wxTHREAD_DETACHED;
}
-wxThreadError wxThread::Create()
+wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
{
if ( m_internal->GetState() != STATE_NEW )
{
#define sched_get_priority_min(_pol_) \
(_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
#endif
-
+
int max_prio = sched_get_priority_max(policy),
min_prio = sched_get_priority_min(policy),
prio = m_internal->GetPriority();
(
m_internal->GetIdPtr(),
&attr,
- wxThreadInternal::PthreadStart,
+ wxPthreadStart,
(void *)this
);
return m_internal->GetPriority();
}
-unsigned long wxThread::GetId() const
+wxThreadIdType wxThread::GetId() const
{
- return (unsigned long)m_internal->GetId();
+ return m_internal->GetId();
}
// -----------------------------------------------------------------------------
if ( m_isDetached )
{
// if we use cleanup function, this will be done from
- // PthreadCleanup()
+ // wxPthreadCleanup()
#if !HAVE_THREAD_CLEANUP_FUNCTIONS
ScheduleThreadForDeletion();
projects / wxWidgets.git / blobdiff