#include <sched.h>
#endif
+#ifdef __WXGTK12__
+#include "gtk/gtk.h"
+#endif
+
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// the key for the pointer to the associated wxThread object
static pthread_key_t gs_keySelf;
+#ifndef __WXGTK12__
// this mutex must be acquired before any call to a GUI function
static wxMutex *gs_mutexGui;
+#endif
// ============================================================================
// implementation
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();
{
wxThread *thread = (wxThread *)ptr;
wxThreadInternal *pthread = thread->p_internal;
+ void *status;
int rc = pthread_setspecific(gs_keySelf, thread);
if ( rc != 0 )
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
// 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;
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
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 -
void wxThreadInternal::Wait()
{
- wxCHECK_RET( WasCancelled(), "thread should have been cancelled first" );
+ 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();
+ printf("Entering wait ...\n");
// entering Wait() releases the mutex thus allowing SignalExit() to acquire
// it and to signal us its termination
m_cond.Wait(m_mutex);
+ printf("Exiting wait ...\n");
// 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
void wxThreadInternal::SignalExit()
{
+ printf("SignalExit\n");
+ // 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();
+ printf("Mutex acquired\n");
// wake up all the threads waiting for our termination
m_cond.Broadcast();
// after this call mutex will be finally unlocked
m_mutex.Unlock();
+ printf("Mutex unacquired\n");
}
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
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);
{
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"));
}
}
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;
}
{
// first call user-level clean up code
OnExit();
+ printf(" ... OnExit()\n");
// next wake up the threads waiting for us (OTOH, this function won't return
// until someone waited for us!)
p_internal->SignalExit();
+ printf(" ... SignalExit()\n");
p_internal->SetState(STATE_EXITED);
+ printf(" ... SetState()\n");
// delete both C++ thread object and terminate the OS thread object
- delete this;
+ // GL: This is very ugly and buggy ...
+// delete this;
+ printf(" ... Exit\n");
pthread_exit(status);
}
}
}
+bool wxThread::IsPaused() const
+{
+ wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
+
+ return (p_internal->GetState() == STATE_PAUSED);
+}
+
//--------------------------------------------------------------------
// wxThreadModule
//--------------------------------------------------------------------
return FALSE;
}
+#ifndef __WXGTK12__
gs_mutexGui = new wxMutex();
-
- //wxThreadGuiInit();
+#endif
gs_tidMain = pthread_self();
+
+#ifndef __WXGTK12__
gs_mutexGui->Lock();
+#endif
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();
}
+#ifndef __WXGTK12__
// destroy GUI mutex
gs_mutexGui->Unlock();
- //wxThreadGuiExit();
-
delete gs_mutexGui;
+#endif
// and free TLD slot
(void)pthread_key_delete(gs_keySelf);
void wxMutexGuiEnter()
{
+#ifdef __WXGTK12__
+ gdk_threads_enter();
+#else
gs_mutexGui->Lock();
+#endif
}
void wxMutexGuiLeave()
{
+#ifdef __WXGTK12__
+ gdk_threads_leave();
+#else
gs_mutexGui->Unlock();
+#endif
}
#endif
projects / wxWidgets.git / blobdiff