#pragma implementation "thread.h"
#endif
-#include "wx/thread.h"
+// With simple makefiles, we must ignore the file body if not using
+// threads.
+#include "wx/setup.h"
-#if !wxUSE_THREADS
- #error This file needs wxUSE_THREADS
-#endif
+#if wxUSE_THREADS
+#include "wx/thread.h"
#include "wx/module.h"
#include "wx/utils.h"
#include "wx/log.h"
#include <errno.h>
#include <time.h>
-#ifdef HAVE_SCHED_H
+#if HAVE_SCHED_H
#include <sched.h>
#endif
// constants
// ----------------------------------------------------------------------------
-enum thread_state
+// the possible states of the thread and transitions from them
+enum wxThreadState
{
STATE_NEW, // didn't start execution yet (=> RUNNING)
- STATE_RUNNING,
- STATE_PAUSED,
- STATE_CANCELED,
- STATE_EXITED
+ STATE_RUNNING, // running (=> PAUSED or EXITED)
+ STATE_PAUSED, // suspended (=> RUNNING or EXITED)
+ STATE_EXITED // thread doesn't exist any more
};
+// ----------------------------------------------------------------------------
+// types
+// ----------------------------------------------------------------------------
+
WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
// -----------------------------------------------------------------------------
wxMutex::wxMutex()
{
p_internal = new wxMutexInternal;
+
pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
m_locked = 0;
}
wxMutex::~wxMutex()
{
if (m_locked > 0)
- wxLogDebug("Freeing a locked mutex (%d locks)", m_locked);
+ wxLogDebug(_T("Freeing a locked mutex (%d locks)"), m_locked);
pthread_mutex_destroy( &(p_internal->p_mutex) );
delete p_internal;
int err = pthread_mutex_lock( &(p_internal->p_mutex) );
if (err == EDEADLK)
{
- wxLogDebug("Locking this mutex would lead to deadlock!");
+ wxLogDebug(_T("Locking this mutex would lead to deadlock!"));
return wxMUTEX_DEAD_LOCK;
}
}
else
{
- wxLogDebug("Unlocking not locked mutex.");
+ wxLogDebug(_T("Unlocking not locked mutex."));
return wxMUTEX_UNLOCKED;
}
// thread entry function
static void *PthreadStart(void *ptr);
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+ // thread exit function
+ static void PthreadCleanup(void *ptr);
+#endif
+
// thread actions
// start the thread
wxThreadError Run();
// ask the thread to terminate
- void Cancel();
+ void Wait();
// wake up threads waiting for our termination
void SignalExit();
// go to sleep until Resume() is called
int GetPriority() const { return m_prio; }
void SetPriority(int prio) { m_prio = prio; }
// state
- thread_state GetState() const { return m_state; }
- void SetState(thread_state state) { m_state = state; }
+ wxThreadState GetState() const { return m_state; }
+ void SetState(wxThreadState state) { m_state = state; }
// id
- pthread_t GetId() const { return thread_id; }
+ pthread_t GetId() const { return m_threadId; }
+ pthread_t *GetIdPtr() { return &m_threadId; }
// "cancelled" flag
+ void SetCancelFlag() { m_cancelled = TRUE; }
bool WasCancelled() const { return m_cancelled; }
-//private: -- should be!
- pthread_t thread_id;
-
private:
- thread_state m_state; // see thread_state enum
- int m_prio; // in wxWindows units: from 0 to 100
+ pthread_t m_threadId; // id of the thread
+ wxThreadState m_state; // see wxThreadState enum
+ int m_prio; // in wxWindows units: from 0 to 100
// set when the thread should terminate
bool m_cancelled;
// this (mutex, cond) pair is used to synchronize the main thread and this
// thread in several situations:
// 1. The thread function blocks until condition is signaled by Run() when
- // it's initially created - this allows create thread in "suspended"
+ // it's initially created - this allows thread creation in "suspended"
// state
// 2. The Delete() function blocks until the condition is signaled when the
// thread exits.
- wxMutex m_mutex;
+ // GL: On Linux, this may fail because we can have a deadlock in either
+ // SignalExit() or Wait(): so we add m_end_mutex for the finalization.
+ wxMutex m_mutex, m_end_mutex;
wxCondition m_cond;
// another (mutex, cond) pair for Pause()/Resume() usage
{
wxThread *thread = (wxThread *)ptr;
wxThreadInternal *pthread = thread->p_internal;
+ void *status;
- if ( pthread_setspecific(gs_keySelf, thread) != 0 )
+ int rc = pthread_setspecific(gs_keySelf, thread);
+ if ( rc != 0 )
{
- wxLogError(_("Can not start thread: error writing TLS."));
+ wxLogSysError(rc, _("Cannot start thread: error writing TLS"));
return (void *)-1;
}
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+ // Install the cleanup handler.
+ pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
+#endif
// wait for the condition to be signaled from Run()
// mutex state: currently locked by the thread which created us
pthread->m_cond.Wait(pthread->m_mutex);
-
// mutex state: locked again on exit of Wait()
// call the main entry
- void* status = thread->Entry();
+ status = thread->Entry();
+
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+ pthread_cleanup_pop(FALSE);
+#endif
// terminate the thread
thread->Exit(status);
- wxFAIL_MSG("wxThread::Exit() can't return.");
+ wxFAIL_MSG(_T("wxThread::Exit() can't return."));
return NULL;
}
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+// Only called when the thread is explicitely killed.
+
+void wxThreadInternal::PthreadCleanup(void *ptr)
+{
+ wxThread *thread = (wxThread *) ptr;
+
+ // The thread is already considered as finished.
+ if (thread->p_internal->GetState() == STATE_EXITED)
+ return;
+
+ // first call user-level clean up code
+ thread->OnExit();
+
+ // next wake up the threads waiting for us (OTOH, this function won't retur
+ // until someone waited for us!)
+ thread->p_internal->SetState(STATE_EXITED);
+
+ thread->p_internal->SignalExit();
+}
+#endif
+
wxThreadInternal::wxThreadInternal()
{
m_state = STATE_NEW;
// this mutex is locked during almost all thread lifetime - it will only be
// unlocked in the very end
m_mutex.Lock();
+
+ // this mutex is used by wxThreadInternal::Wait() and by
+ // wxThreadInternal::SignalExit(). We don't use m_mutex because of a
+ // possible deadlock in either Wait() or SignalExit().
+ m_end_mutex.Lock();
// this mutex is used in Pause()/Resume() and is also locked all the time
// unless the thread is paused
wxThreadInternal::~wxThreadInternal()
{
- m_mutexSuspend.Unlock();
+ // GL: moved to SignalExit
+ // m_mutexSuspend.Unlock();
// note that m_mutex will be unlocked by the thread which waits for our
// termination
+
+ // In the case, we didn't start the thread, all these mutex are locked:
+ // we must unlock them.
+ if (m_mutex.IsLocked())
+ m_mutex.Unlock();
+
+ if (m_end_mutex.IsLocked())
+ m_end_mutex.Unlock();
+
+ if (m_mutexSuspend.IsLocked())
+ m_mutexSuspend.Unlock();
}
wxThreadError wxThreadInternal::Run()
{
wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
- "thread may only be started once after successful Create()" );
+ _T("thread may only be started once after successful Create()") );
// the mutex was locked on Create(), so we will be able to lock it again
// only when the thread really starts executing and enters the wait -
// starts executing and the mutex is still locked
}
-void wxThreadInternal::Cancel()
+void wxThreadInternal::Wait()
{
+ wxCHECK_RET( WasCancelled(), _T("thread should have been cancelled first") );
+
// if the thread we're waiting for is waiting for the GUI mutex, we will
// deadlock so make sure we release it temporarily
if ( wxThread::IsMain() )
wxMutexGuiLeave();
- // nobody ever writes this variable so it's safe to not use any
- // synchronization here
- m_cancelled = TRUE;
-
// entering Wait() releases the mutex thus allowing SignalExit() to acquire
// it and to signal us its termination
- m_cond.Wait(m_mutex);
+ m_cond.Wait(m_end_mutex);
// mutex is still in the locked state - relocked on exit from Wait(), so
// unlock it - we don't need it any more, the thread has already terminated
- m_mutex.Unlock();
+ m_end_mutex.Unlock();
+
+ // After that, we wait for the real end of the other thread.
+ pthread_join(GetId(), NULL);
// reacquire GUI mutex
if ( wxThread::IsMain() )
void wxThreadInternal::SignalExit()
{
+ // GL: Unlock mutexSuspend here.
+ m_mutexSuspend.Unlock();
+
// as mutex is currently locked, this will block until some other thread
// (normally the same which created this one) unlocks it by entering Wait()
- m_mutex.Lock();
+ m_end_mutex.Lock();
// wake up all the threads waiting for our termination
m_cond.Broadcast();
// after this call mutex will be finally unlocked
- m_mutex.Unlock();
+ m_end_mutex.Unlock();
}
void wxThreadInternal::Pause()
{
+ // the state is set from the thread which pauses us first, this function
+ // is called later so the state should have been already set
wxCHECK_RET( m_state == STATE_PAUSED,
- "thread must first be paused with wxThread::Pause()." );
+ _T("thread must first be paused with wxThread::Pause().") );
+
+ // don't pause the thread which is being terminated - this would lead to
+ // deadlock if the thread is paused after Delete() had called Resume() but
+ // before it had time to call Wait()
+ if ( WasCancelled() )
+ return;
// wait until the condition is signaled from Resume()
m_condSuspend.Wait(m_mutexSuspend);
void wxThreadInternal::Resume()
{
wxCHECK_RET( m_state == STATE_PAUSED,
- "can't resume thread which is not suspended." );
+ _T("can't resume thread which is not suspended.") );
// we will be able to lock this mutex only when Pause() starts waiting
wxMutexLocker lock(m_mutexSuspend);
pthread_attr_t attr;
pthread_attr_init(&attr);
+#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
int prio;
if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 )
{
- wxLogError(_("Can not retrieve thread scheduling policy."));
+ wxLogError(_("Cannot retrieve thread scheduling policy."));
}
-#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
int min_prio = sched_get_priority_min(prio),
max_prio = sched_get_priority_max(prio);
if ( min_prio == -1 || max_prio == -1 )
{
- wxLogError(_("Can not get priority range for scheduling policy %d."),
+ wxLogError(_("Cannot get priority range for scheduling policy %d."),
prio);
}
else
}
#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
+#ifdef HAVE_PTHREAD_ATTR_SETSCOPE
+ // this will make the threads created by this process really concurrent
+ pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
+#endif // HAVE_PTHREAD_ATTR_SETSCOPE
+
// create the new OS thread object
- int rc = pthread_create(&p_internal->thread_id, &attr,
+ int rc = pthread_create(p_internal->GetIdPtr(), &attr,
wxThreadInternal::PthreadStart, (void *)this);
pthread_attr_destroy(&attr);
{
wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
- "invalid thread priority" );
+ _T("invalid thread priority") );
wxCriticalSectionLocker lock(m_critsect);
case STATE_EXITED:
default:
- wxFAIL_MSG("impossible to set thread priority in this state");
+ wxFAIL_MSG(_T("impossible to set thread priority in this state"));
}
}
unsigned long wxThread::GetID() const
{
- return (unsigned long)p_internal->thread_id;
+ return (unsigned long)p_internal->GetId();
}
// -----------------------------------------------------------------------------
if ( p_internal->GetState() != STATE_RUNNING )
{
- wxLogDebug("Can't pause thread which is not running.");
+ wxLogDebug(_T("Can't pause thread which is not running."));
return wxTHREAD_NOT_RUNNING;
}
if ( p_internal->GetState() == STATE_PAUSED )
{
+ m_critsect.Leave();
p_internal->Resume();
+ m_critsect.Enter();
return wxTHREAD_NO_ERROR;
}
else
{
- wxLogDebug("Attempt to resume a thread which is not paused.");
+ wxLogDebug(_T("Attempt to resume a thread which is not paused."));
return wxTHREAD_MISC_ERROR;
}
wxThread::ExitCode wxThread::Delete()
{
+ if (IsPaused())
+ Resume();
+
m_critsect.Enter();
- thread_state state = p_internal->GetState();
+ wxThreadState state = p_internal->GetState();
+
+ // ask the thread to stop
+ p_internal->SetCancelFlag();
+
m_critsect.Leave();
switch ( state )
// fall through
default:
- // set the flag telling to the thread to stop and wait
- p_internal->Cancel();
+ // wait until the thread stops
+ p_internal->Wait();
}
+ //GL: As we must auto-destroy, the destruction must happen here.
+ delete this;
return NULL;
}
return wxTHREAD_MISC_ERROR;
}
+ //GL: As we must auto-destroy, the destruction must happen here (2).
+ delete this;
return wxTHREAD_NO_ERROR;
}
p_internal->SetState(STATE_EXITED);
// delete both C++ thread object and terminate the OS thread object
- delete this;
+ // GL: This is very ugly and buggy ...
+// delete this;
pthread_exit(status);
}
// also test whether we were paused
bool wxThread::TestDestroy()
{
- wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
+ wxCriticalSectionLocker lock(m_critsect);
if ( p_internal->GetState() == STATE_PAUSED )
{
wxThread::~wxThread()
{
+ m_critsect.Enter();
+ if (p_internal->GetState() != STATE_EXITED &&
+ p_internal->GetState() != STATE_NEW)
+ wxLogDebug(_T("The thread is being destroyed althought it is still running ! The application may crash."));
+
+ m_critsect.Leave();
+
+ delete p_internal;
// remove this thread from the global array
gs_allThreads.Remove(this);
}
}
}
+bool wxThread::IsPaused() const
+{
+ wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
+
+ return (p_internal->GetState() == STATE_PAUSED);
+}
+
//--------------------------------------------------------------------
// wxThreadModule
//--------------------------------------------------------------------
bool wxThreadModule::OnInit()
{
- if ( pthread_key_create(&gs_keySelf, NULL /* dtor function */) != 0 )
+ int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
+ if ( rc != 0 )
{
- wxLogError(_("Thread module initialization failed: "
- "failed to create pthread key."));
+ wxLogSysError(rc, _("Thread module initialization failed: "
+ "failed to create thread key"));
return FALSE;
}
gs_mutexGui = new wxMutex();
- //wxThreadGuiInit();
-
gs_tidMain = pthread_self();
+
gs_mutexGui->Lock();
return TRUE;
void wxThreadModule::OnExit()
{
- wxASSERT_MSG( wxThread::IsMain(), "only main thread can be here" );
+ wxASSERT_MSG( wxThread::IsMain(), _T("only main thread can be here") );
// terminate any threads left
size_t count = gs_allThreads.GetCount();
if ( count != 0u )
- wxLogDebug("Some threads were not terminated by the application.");
+ wxLogDebug(_T("Some threads were not terminated by the application."));
for ( size_t n = 0u; n < count; n++ )
{
- gs_allThreads[n]->Delete();
+ // Delete calls the destructor which removes the current entry. We
+ // should only delete the first one each time.
+ gs_allThreads[0]->Delete();
}
// destroy GUI mutex
gs_mutexGui->Unlock();
- //wxThreadGuiExit();
-
delete gs_mutexGui;
// and free TLD slot
{
gs_mutexGui->Unlock();
}
+
+#endif
+ // wxUSE_THREADS
projects / wxWidgets.git / blobdiff