Removed obsolete files
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@9248 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
parent
4161828546
commit
0c6b0c6668
@ -1,7 +0,0 @@
|
||||
#ifndef _WX_PLOT_H_BASE_
|
||||
#define _WX_PLOT_H_BASE_
|
||||
|
||||
#include "wx/generic/plot.h"
|
||||
|
||||
#endif
|
||||
// _WX_PLOT_H_BASE_
|
||||
@ -1,758 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: threadpsx.cpp
|
||||
// Purpose: wxThread (Posix) Implementation
|
||||
// Author: Original from Wolfram Gloger/Guilhem Lavaux
|
||||
// Modified by:
|
||||
// Created: 04/22/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Wolfram Gloger (1996, 1997)
|
||||
// Guilhem Lavaux (1998)
|
||||
// Robert Roebling (1999)
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "thread.h"
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <pthread.h>
|
||||
#include <errno.h>
|
||||
|
||||
#ifdef __linux__
|
||||
#include <sched.h>
|
||||
#endif
|
||||
|
||||
#ifdef __SUN__
|
||||
extern int usleep(unsigned int useconds);
|
||||
#endif
|
||||
|
||||
|
||||
#include "wx/thread.h"
|
||||
#include "wx/module.h"
|
||||
#include "wx/utils.h"
|
||||
#include "wx/log.h"
|
||||
#include "wx/intl.h"
|
||||
#include "wx/dynarray.h"
|
||||
|
||||
#include "gdk/gdk.h"
|
||||
#include "gtk/gtk.h"
|
||||
|
||||
enum thread_state
|
||||
{
|
||||
STATE_NEW, // didn't start execution yet (=> RUNNING)
|
||||
STATE_RUNNING,
|
||||
STATE_PAUSED,
|
||||
STATE_CANCELED,
|
||||
STATE_EXITED
|
||||
};
|
||||
|
||||
WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// global data
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
// we keep the list of all threads created by the application to be able to
|
||||
// terminate them on exit if there are some left - otherwise the process would
|
||||
// be left in memory
|
||||
static wxArrayThread gs_allThreads;
|
||||
|
||||
// the id of the main thread
|
||||
static pthread_t gs_tidMain;
|
||||
|
||||
// the key for the pointer to the associated wxThread object
|
||||
static pthread_key_t gs_keySelf;
|
||||
|
||||
// this mutex must be acquired before any call to a GUI function
|
||||
static wxMutex *gs_mutexGui;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// common GUI thread code
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
#include "threadgui.inc"
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// wxMutex (Posix implementation)
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
class wxMutexInternal
|
||||
{
|
||||
public:
|
||||
pthread_mutex_t p_mutex;
|
||||
};
|
||||
|
||||
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);
|
||||
|
||||
pthread_mutex_destroy( &(p_internal->p_mutex) );
|
||||
delete p_internal;
|
||||
}
|
||||
|
||||
wxMutexError wxMutex::Lock()
|
||||
{
|
||||
int err = pthread_mutex_lock( &(p_internal->p_mutex) );
|
||||
if (err == EDEADLK)
|
||||
{
|
||||
wxLogDebug("Locking this mutex would lead to deadlock!");
|
||||
|
||||
return wxMUTEX_DEAD_LOCK;
|
||||
}
|
||||
|
||||
m_locked++;
|
||||
|
||||
return wxMUTEX_NO_ERROR;
|
||||
}
|
||||
|
||||
wxMutexError wxMutex::TryLock()
|
||||
{
|
||||
if (m_locked)
|
||||
{
|
||||
return wxMUTEX_BUSY;
|
||||
}
|
||||
|
||||
int err = pthread_mutex_trylock( &(p_internal->p_mutex) );
|
||||
switch (err)
|
||||
{
|
||||
case EBUSY: return wxMUTEX_BUSY;
|
||||
}
|
||||
|
||||
m_locked++;
|
||||
|
||||
return wxMUTEX_NO_ERROR;
|
||||
}
|
||||
|
||||
wxMutexError wxMutex::Unlock()
|
||||
{
|
||||
if (m_locked > 0)
|
||||
{
|
||||
m_locked--;
|
||||
}
|
||||
else
|
||||
{
|
||||
wxLogDebug("Unlocking not locked mutex.");
|
||||
|
||||
return wxMUTEX_UNLOCKED;
|
||||
}
|
||||
|
||||
pthread_mutex_unlock( &(p_internal->p_mutex) );
|
||||
|
||||
return wxMUTEX_NO_ERROR;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// wxCondition (Posix implementation)
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
class wxConditionInternal
|
||||
{
|
||||
public:
|
||||
pthread_cond_t p_condition;
|
||||
};
|
||||
|
||||
wxCondition::wxCondition()
|
||||
{
|
||||
p_internal = new wxConditionInternal;
|
||||
pthread_cond_init( &(p_internal->p_condition), (const pthread_condattr_t *) NULL );
|
||||
}
|
||||
|
||||
wxCondition::~wxCondition()
|
||||
{
|
||||
pthread_cond_destroy( &(p_internal->p_condition) );
|
||||
|
||||
delete p_internal;
|
||||
}
|
||||
|
||||
void wxCondition::Wait(wxMutex& mutex)
|
||||
{
|
||||
pthread_cond_wait( &(p_internal->p_condition), &(mutex.p_internal->p_mutex) );
|
||||
}
|
||||
|
||||
bool wxCondition::Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec)
|
||||
{
|
||||
struct timespec tspec;
|
||||
|
||||
tspec.tv_sec = time(0L)+sec;
|
||||
tspec.tv_nsec = nsec;
|
||||
return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
|
||||
}
|
||||
|
||||
void wxCondition::Signal()
|
||||
{
|
||||
pthread_cond_signal( &(p_internal->p_condition) );
|
||||
}
|
||||
|
||||
void wxCondition::Broadcast()
|
||||
{
|
||||
pthread_cond_broadcast( &(p_internal->p_condition) );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// wxThread (Posix implementation)
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
class wxThreadInternal
|
||||
{
|
||||
public:
|
||||
wxThreadInternal();
|
||||
~wxThreadInternal();
|
||||
|
||||
// thread entry function
|
||||
static void *PthreadStart(void *ptr);
|
||||
|
||||
// thread actions
|
||||
// start the thread
|
||||
wxThreadError Run();
|
||||
// ask the thread to terminate
|
||||
void Cancel();
|
||||
// wake up threads waiting for our termination
|
||||
void SignalExit();
|
||||
// go to sleep until Resume() is called
|
||||
void Pause();
|
||||
// resume the thread
|
||||
void Resume();
|
||||
|
||||
// accessors
|
||||
// priority
|
||||
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; }
|
||||
// id
|
||||
pthread_t GetId() const { return thread_id; }
|
||||
// "cancelled" flag
|
||||
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
|
||||
|
||||
// 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"
|
||||
// state
|
||||
// 2. The Delete() function blocks until the condition is signaled when the
|
||||
// thread exits.
|
||||
wxMutex m_mutex;
|
||||
wxCondition m_cond;
|
||||
|
||||
// another (mutex, cond) pair for Pause()/Resume() usage
|
||||
//
|
||||
// VZ: it's possible that we might reuse the mutex and condition from above
|
||||
// for this too, but as I'm not at all sure that it won't create subtle
|
||||
// problems with race conditions between, say, Pause() and Delete() I
|
||||
// prefer this may be a bit less efficient but much safer solution
|
||||
wxMutex m_mutexSuspend;
|
||||
wxCondition m_condSuspend;
|
||||
};
|
||||
|
||||
void *wxThreadInternal::PthreadStart(void *ptr)
|
||||
{
|
||||
wxThread *thread = (wxThread *)ptr;
|
||||
wxThreadInternal *pthread = thread->p_internal;
|
||||
|
||||
if ( pthread_setspecific(gs_keySelf, thread) != 0 )
|
||||
{
|
||||
wxLogError(_("Can not start thread: error writing TLS."));
|
||||
|
||||
return (void *)-1;
|
||||
}
|
||||
|
||||
// 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();
|
||||
|
||||
// terminate the thread
|
||||
thread->Exit(status);
|
||||
|
||||
wxFAIL_MSG("wxThread::Exit() can't return.");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
wxThreadInternal::wxThreadInternal()
|
||||
{
|
||||
m_state = STATE_NEW;
|
||||
m_cancelled = FALSE;
|
||||
|
||||
// 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 in Pause()/Resume() and is also locked all the time
|
||||
// unless the thread is paused
|
||||
m_mutexSuspend.Lock();
|
||||
}
|
||||
|
||||
wxThreadInternal::~wxThreadInternal()
|
||||
{
|
||||
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()" );
|
||||
|
||||
// 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 -
|
||||
// otherwise we might signal the condition before anybody is waiting for it
|
||||
wxMutexLocker lock(m_mutex);
|
||||
m_cond.Signal();
|
||||
|
||||
m_state = STATE_RUNNING;
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
|
||||
// now the mutex is unlocked back - but just to allow Wait() function to
|
||||
// terminate by relocking it, so the net result is that the worker thread
|
||||
// starts executing and the mutex is still locked
|
||||
}
|
||||
|
||||
void wxThreadInternal::Cancel()
|
||||
{
|
||||
// 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);
|
||||
|
||||
// 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();
|
||||
|
||||
// reacquire GUI mutex
|
||||
if ( wxThread::IsMain() )
|
||||
wxMutexGuiEnter();
|
||||
}
|
||||
|
||||
void wxThreadInternal::SignalExit()
|
||||
{
|
||||
// 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();
|
||||
|
||||
// wake up all the threads waiting for our termination
|
||||
m_cond.Broadcast();
|
||||
|
||||
// after this call mutex will be finally unlocked
|
||||
m_mutex.Unlock();
|
||||
}
|
||||
|
||||
void wxThreadInternal::Pause()
|
||||
{
|
||||
wxCHECK_RET( m_state == STATE_PAUSED,
|
||||
"thread must first be paused with wxThread::Pause()." );
|
||||
|
||||
// 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." );
|
||||
|
||||
// we will be able to lock this mutex only when Pause() starts waiting
|
||||
wxMutexLocker lock(m_mutexSuspend);
|
||||
m_condSuspend.Signal();
|
||||
|
||||
SetState(STATE_RUNNING);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// static functions
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
wxThread *wxThread::This()
|
||||
{
|
||||
return (wxThread *)pthread_getspecific(gs_keySelf);
|
||||
}
|
||||
|
||||
bool wxThread::IsMain()
|
||||
{
|
||||
return (bool)pthread_equal(pthread_self(), gs_tidMain);
|
||||
}
|
||||
|
||||
void wxThread::Yield()
|
||||
{
|
||||
#ifdef HAVE_SCHED_YIELD
|
||||
sched_yield();
|
||||
#else // !HAVE_SCHED_YIELD
|
||||
// may be it will have the desired effect?
|
||||
Sleep(0);
|
||||
#endif // HAVE_SCHED_YIELD
|
||||
}
|
||||
|
||||
void wxThread::Sleep(unsigned long milliseconds)
|
||||
{
|
||||
wxUsleep(milliseconds);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// creating thread
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
wxThread::wxThread()
|
||||
{
|
||||
// add this thread to the global list of all threads
|
||||
gs_allThreads.Add(this);
|
||||
|
||||
p_internal = new wxThreadInternal();
|
||||
}
|
||||
|
||||
wxThreadError wxThread::Create()
|
||||
{
|
||||
if (p_internal->GetState() != STATE_NEW)
|
||||
return wxTHREAD_RUNNING;
|
||||
|
||||
// set up the thread attribute: right now, we only set thread priority
|
||||
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."));
|
||||
}
|
||||
|
||||
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."),
|
||||
prio);
|
||||
}
|
||||
else
|
||||
{
|
||||
struct sched_param sp;
|
||||
pthread_attr_getschedparam(&attr, &sp);
|
||||
sp.sched_priority = min_prio +
|
||||
(p_internal->GetPriority()*(max_prio-min_prio))/100;
|
||||
pthread_attr_setschedparam(&attr, &sp);
|
||||
}
|
||||
#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
|
||||
|
||||
// create the new OS thread object
|
||||
int rc = pthread_create(&p_internal->thread_id, &attr,
|
||||
wxThreadInternal::PthreadStart, (void *)this);
|
||||
pthread_attr_destroy(&attr);
|
||||
|
||||
if ( rc != 0 )
|
||||
{
|
||||
p_internal->SetState(STATE_EXITED);
|
||||
return wxTHREAD_NO_RESOURCE;
|
||||
}
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
}
|
||||
|
||||
wxThreadError wxThread::Run()
|
||||
{
|
||||
return p_internal->Run();
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// misc accessors
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
void wxThread::SetPriority(unsigned int prio)
|
||||
{
|
||||
wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
|
||||
((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
|
||||
"invalid thread priority" );
|
||||
|
||||
wxCriticalSectionLocker lock(m_critsect);
|
||||
|
||||
switch ( p_internal->GetState() )
|
||||
{
|
||||
case STATE_NEW:
|
||||
// thread not yet started, priority will be set when it is
|
||||
p_internal->SetPriority(prio);
|
||||
break;
|
||||
|
||||
case STATE_RUNNING:
|
||||
case STATE_PAUSED:
|
||||
#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
|
||||
{
|
||||
struct sched_param sparam;
|
||||
sparam.sched_priority = prio;
|
||||
|
||||
if ( pthread_setschedparam(p_internal->GetId(),
|
||||
SCHED_OTHER, &sparam) != 0 )
|
||||
{
|
||||
wxLogError(_("Failed to set thread priority %d."), prio);
|
||||
}
|
||||
}
|
||||
#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
|
||||
break;
|
||||
|
||||
case STATE_EXITED:
|
||||
default:
|
||||
wxFAIL_MSG("impossible to set thread priority in this state");
|
||||
}
|
||||
}
|
||||
|
||||
unsigned int wxThread::GetPriority() const
|
||||
{
|
||||
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
|
||||
|
||||
return p_internal->GetPriority();
|
||||
}
|
||||
|
||||
unsigned long wxThread::GetID() const
|
||||
{
|
||||
return (unsigned long)p_internal->thread_id;
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// pause/resume
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
wxThreadError wxThread::Pause()
|
||||
{
|
||||
wxCriticalSectionLocker lock(m_critsect);
|
||||
|
||||
if ( p_internal->GetState() != STATE_RUNNING )
|
||||
{
|
||||
wxLogDebug("Can't pause thread which is not running.");
|
||||
|
||||
return wxTHREAD_NOT_RUNNING;
|
||||
}
|
||||
|
||||
p_internal->SetState(STATE_PAUSED);
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
}
|
||||
|
||||
wxThreadError wxThread::Resume()
|
||||
{
|
||||
wxCriticalSectionLocker lock(m_critsect);
|
||||
|
||||
if ( p_internal->GetState() == STATE_PAUSED )
|
||||
{
|
||||
p_internal->Resume();
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
wxLogDebug("Attempt to resume a thread which is not paused.");
|
||||
|
||||
return wxTHREAD_MISC_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// exiting thread
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
wxThread::ExitCode wxThread::Delete()
|
||||
{
|
||||
m_critsect.Enter();
|
||||
thread_state state = p_internal->GetState();
|
||||
m_critsect.Leave();
|
||||
|
||||
switch ( state )
|
||||
{
|
||||
case STATE_NEW:
|
||||
case STATE_EXITED:
|
||||
// nothing to do
|
||||
break;
|
||||
|
||||
case STATE_PAUSED:
|
||||
// resume the thread first
|
||||
Resume();
|
||||
|
||||
// fall through
|
||||
|
||||
default:
|
||||
// set the flag telling to the thread to stop and wait
|
||||
p_internal->Cancel();
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
wxThreadError wxThread::Kill()
|
||||
{
|
||||
switch ( p_internal->GetState() )
|
||||
{
|
||||
case STATE_NEW:
|
||||
case STATE_EXITED:
|
||||
return wxTHREAD_NOT_RUNNING;
|
||||
|
||||
default:
|
||||
#ifdef HAVE_PTHREAD_CANCEL
|
||||
if ( pthread_cancel(p_internal->GetId()) != 0 )
|
||||
#endif
|
||||
{
|
||||
wxLogError(_("Failed to terminate a thread."));
|
||||
|
||||
return wxTHREAD_MISC_ERROR;
|
||||
}
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
void wxThread::Exit(void *status)
|
||||
{
|
||||
// first call user-level clean up code
|
||||
OnExit();
|
||||
|
||||
// next wake up the threads waiting for us (OTOH, this function won't return
|
||||
// until someone waited for us!)
|
||||
p_internal->SignalExit();
|
||||
|
||||
p_internal->SetState(STATE_EXITED);
|
||||
|
||||
// delete both C++ thread object and terminate the OS thread object
|
||||
delete this;
|
||||
pthread_exit(status);
|
||||
}
|
||||
|
||||
// also test whether we were paused
|
||||
bool wxThread::TestDestroy()
|
||||
{
|
||||
wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
|
||||
|
||||
if ( p_internal->GetState() == STATE_PAUSED )
|
||||
{
|
||||
// leave the crit section or the other threads will stop too if they try
|
||||
// to call any of (seemingly harmless) IsXXX() functions while we sleep
|
||||
m_critsect.Leave();
|
||||
|
||||
p_internal->Pause();
|
||||
|
||||
// enter it back before it's finally left in lock object dtor
|
||||
m_critsect.Enter();
|
||||
}
|
||||
|
||||
return p_internal->WasCancelled();
|
||||
}
|
||||
|
||||
wxThread::~wxThread()
|
||||
{
|
||||
// remove this thread from the global array
|
||||
gs_allThreads.Remove(this);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// state tests
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
bool wxThread::IsRunning() const
|
||||
{
|
||||
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
|
||||
|
||||
return p_internal->GetState() == STATE_RUNNING;
|
||||
}
|
||||
|
||||
bool wxThread::IsAlive() const
|
||||
{
|
||||
wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
|
||||
|
||||
switch ( p_internal->GetState() )
|
||||
{
|
||||
case STATE_RUNNING:
|
||||
case STATE_PAUSED:
|
||||
return TRUE;
|
||||
|
||||
default:
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// wxThreadModule
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
class wxThreadModule : public wxModule
|
||||
{
|
||||
public:
|
||||
virtual bool OnInit();
|
||||
virtual void OnExit();
|
||||
|
||||
private:
|
||||
DECLARE_DYNAMIC_CLASS(wxThreadModule)
|
||||
};
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
|
||||
|
||||
bool wxThreadModule::OnInit()
|
||||
{
|
||||
if ( pthread_key_create(&gs_keySelf, NULL /* dtor function */) != 0 )
|
||||
{
|
||||
wxLogError(_("Thread module initialization failed: "
|
||||
"failed to create pthread 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" );
|
||||
|
||||
// terminate any threads left
|
||||
size_t count = gs_allThreads.GetCount();
|
||||
if ( count != 0u )
|
||||
wxLogDebug("Some threads were not terminated by the application.");
|
||||
|
||||
for ( size_t n = 0u; n < count; n++ )
|
||||
{
|
||||
gs_allThreads[n]->Delete();
|
||||
}
|
||||
|
||||
// destroy GUI mutex
|
||||
gs_mutexGui->Unlock();
|
||||
wxThreadGuiExit();
|
||||
delete gs_mutexGui;
|
||||
|
||||
// and free TLD slot
|
||||
(void)pthread_key_delete(gs_keySelf);
|
||||
}
|
||||
@ -1,758 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: threadpsx.cpp
|
||||
// Purpose: wxThread (Posix) Implementation
|
||||
// Author: Original from Wolfram Gloger/Guilhem Lavaux
|
||||
// Modified by:
|
||||
// Created: 04/22/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Wolfram Gloger (1996, 1997)
|
||||
// Guilhem Lavaux (1998)
|
||||
// Robert Roebling (1999)
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "thread.h"
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <pthread.h>
|
||||
#include <errno.h>
|
||||
|
||||
#ifdef __linux__
|
||||
#include <sched.h>
|
||||
#endif
|
||||
|
||||
#ifdef __SUN__
|
||||
extern int usleep(unsigned int useconds);
|
||||
#endif
|
||||
|
||||
|
||||
#include "wx/thread.h"
|
||||
#include "wx/module.h"
|
||||
#include "wx/utils.h"
|
||||
#include "wx/log.h"
|
||||
#include "wx/intl.h"
|
||||
#include "wx/dynarray.h"
|
||||
|
||||
#include "gdk/gdk.h"
|
||||
#include "gtk/gtk.h"
|
||||
|
||||
enum thread_state
|
||||
{
|
||||
STATE_NEW, // didn't start execution yet (=> RUNNING)
|
||||
STATE_RUNNING,
|
||||
STATE_PAUSED,
|
||||
STATE_CANCELED,
|
||||
STATE_EXITED
|
||||
};
|
||||
|
||||
WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// global data
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
// we keep the list of all threads created by the application to be able to
|
||||
// terminate them on exit if there are some left - otherwise the process would
|
||||
// be left in memory
|
||||
static wxArrayThread gs_allThreads;
|
||||
|
||||
// the id of the main thread
|
||||
static pthread_t gs_tidMain;
|
||||
|
||||
// the key for the pointer to the associated wxThread object
|
||||
static pthread_key_t gs_keySelf;
|
||||
|
||||
// this mutex must be acquired before any call to a GUI function
|
||||
static wxMutex *gs_mutexGui;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// common GUI thread code
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
#include "threadgui.inc"
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// wxMutex (Posix implementation)
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
class wxMutexInternal
|
||||
{
|
||||
public:
|
||||
pthread_mutex_t p_mutex;
|
||||
};
|
||||
|
||||
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);
|
||||
|
||||
pthread_mutex_destroy( &(p_internal->p_mutex) );
|
||||
delete p_internal;
|
||||
}
|
||||
|
||||
wxMutexError wxMutex::Lock()
|
||||
{
|
||||
int err = pthread_mutex_lock( &(p_internal->p_mutex) );
|
||||
if (err == EDEADLK)
|
||||
{
|
||||
wxLogDebug("Locking this mutex would lead to deadlock!");
|
||||
|
||||
return wxMUTEX_DEAD_LOCK;
|
||||
}
|
||||
|
||||
m_locked++;
|
||||
|
||||
return wxMUTEX_NO_ERROR;
|
||||
}
|
||||
|
||||
wxMutexError wxMutex::TryLock()
|
||||
{
|
||||
if (m_locked)
|
||||
{
|
||||
return wxMUTEX_BUSY;
|
||||
}
|
||||
|
||||
int err = pthread_mutex_trylock( &(p_internal->p_mutex) );
|
||||
switch (err)
|
||||
{
|
||||
case EBUSY: return wxMUTEX_BUSY;
|
||||
}
|
||||
|
||||
m_locked++;
|
||||
|
||||
return wxMUTEX_NO_ERROR;
|
||||
}
|
||||
|
||||
wxMutexError wxMutex::Unlock()
|
||||
{
|
||||
if (m_locked > 0)
|
||||
{
|
||||
m_locked--;
|
||||
}
|
||||
else
|
||||
{
|
||||
wxLogDebug("Unlocking not locked mutex.");
|
||||
|
||||
return wxMUTEX_UNLOCKED;
|
||||
}
|
||||
|
||||
pthread_mutex_unlock( &(p_internal->p_mutex) );
|
||||
|
||||
return wxMUTEX_NO_ERROR;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// wxCondition (Posix implementation)
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
class wxConditionInternal
|
||||
{
|
||||
public:
|
||||
pthread_cond_t p_condition;
|
||||
};
|
||||
|
||||
wxCondition::wxCondition()
|
||||
{
|
||||
p_internal = new wxConditionInternal;
|
||||
pthread_cond_init( &(p_internal->p_condition), (const pthread_condattr_t *) NULL );
|
||||
}
|
||||
|
||||
wxCondition::~wxCondition()
|
||||
{
|
||||
pthread_cond_destroy( &(p_internal->p_condition) );
|
||||
|
||||
delete p_internal;
|
||||
}
|
||||
|
||||
void wxCondition::Wait(wxMutex& mutex)
|
||||
{
|
||||
pthread_cond_wait( &(p_internal->p_condition), &(mutex.p_internal->p_mutex) );
|
||||
}
|
||||
|
||||
bool wxCondition::Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec)
|
||||
{
|
||||
struct timespec tspec;
|
||||
|
||||
tspec.tv_sec = time(0L)+sec;
|
||||
tspec.tv_nsec = nsec;
|
||||
return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
|
||||
}
|
||||
|
||||
void wxCondition::Signal()
|
||||
{
|
||||
pthread_cond_signal( &(p_internal->p_condition) );
|
||||
}
|
||||
|
||||
void wxCondition::Broadcast()
|
||||
{
|
||||
pthread_cond_broadcast( &(p_internal->p_condition) );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// wxThread (Posix implementation)
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
class wxThreadInternal
|
||||
{
|
||||
public:
|
||||
wxThreadInternal();
|
||||
~wxThreadInternal();
|
||||
|
||||
// thread entry function
|
||||
static void *PthreadStart(void *ptr);
|
||||
|
||||
// thread actions
|
||||
// start the thread
|
||||
wxThreadError Run();
|
||||
// ask the thread to terminate
|
||||
void Cancel();
|
||||
// wake up threads waiting for our termination
|
||||
void SignalExit();
|
||||
// go to sleep until Resume() is called
|
||||
void Pause();
|
||||
// resume the thread
|
||||
void Resume();
|
||||
|
||||
// accessors
|
||||
// priority
|
||||
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; }
|
||||
// id
|
||||
pthread_t GetId() const { return thread_id; }
|
||||
// "cancelled" flag
|
||||
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
|
||||
|
||||
// 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"
|
||||
// state
|
||||
// 2. The Delete() function blocks until the condition is signaled when the
|
||||
// thread exits.
|
||||
wxMutex m_mutex;
|
||||
wxCondition m_cond;
|
||||
|
||||
// another (mutex, cond) pair for Pause()/Resume() usage
|
||||
//
|
||||
// VZ: it's possible that we might reuse the mutex and condition from above
|
||||
// for this too, but as I'm not at all sure that it won't create subtle
|
||||
// problems with race conditions between, say, Pause() and Delete() I
|
||||
// prefer this may be a bit less efficient but much safer solution
|
||||
wxMutex m_mutexSuspend;
|
||||
wxCondition m_condSuspend;
|
||||
};
|
||||
|
||||
void *wxThreadInternal::PthreadStart(void *ptr)
|
||||
{
|
||||
wxThread *thread = (wxThread *)ptr;
|
||||
wxThreadInternal *pthread = thread->p_internal;
|
||||
|
||||
if ( pthread_setspecific(gs_keySelf, thread) != 0 )
|
||||
{
|
||||
wxLogError(_("Can not start thread: error writing TLS."));
|
||||
|
||||
return (void *)-1;
|
||||
}
|
||||
|
||||
// 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();
|
||||
|
||||
// terminate the thread
|
||||
thread->Exit(status);
|
||||
|
||||
wxFAIL_MSG("wxThread::Exit() can't return.");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
wxThreadInternal::wxThreadInternal()
|
||||
{
|
||||
m_state = STATE_NEW;
|
||||
m_cancelled = FALSE;
|
||||
|
||||
// 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 in Pause()/Resume() and is also locked all the time
|
||||
// unless the thread is paused
|
||||
m_mutexSuspend.Lock();
|
||||
}
|
||||
|
||||
wxThreadInternal::~wxThreadInternal()
|
||||
{
|
||||
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()" );
|
||||
|
||||
// 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 -
|
||||
// otherwise we might signal the condition before anybody is waiting for it
|
||||
wxMutexLocker lock(m_mutex);
|
||||
m_cond.Signal();
|
||||
|
||||
m_state = STATE_RUNNING;
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
|
||||
// now the mutex is unlocked back - but just to allow Wait() function to
|
||||
// terminate by relocking it, so the net result is that the worker thread
|
||||
// starts executing and the mutex is still locked
|
||||
}
|
||||
|
||||
void wxThreadInternal::Cancel()
|
||||
{
|
||||
// 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);
|
||||
|
||||
// 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();
|
||||
|
||||
// reacquire GUI mutex
|
||||
if ( wxThread::IsMain() )
|
||||
wxMutexGuiEnter();
|
||||
}
|
||||
|
||||
void wxThreadInternal::SignalExit()
|
||||
{
|
||||
// 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();
|
||||
|
||||
// wake up all the threads waiting for our termination
|
||||
m_cond.Broadcast();
|
||||
|
||||
// after this call mutex will be finally unlocked
|
||||
m_mutex.Unlock();
|
||||
}
|
||||
|
||||
void wxThreadInternal::Pause()
|
||||
{
|
||||
wxCHECK_RET( m_state == STATE_PAUSED,
|
||||
"thread must first be paused with wxThread::Pause()." );
|
||||
|
||||
// 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." );
|
||||
|
||||
// we will be able to lock this mutex only when Pause() starts waiting
|
||||
wxMutexLocker lock(m_mutexSuspend);
|
||||
m_condSuspend.Signal();
|
||||
|
||||
SetState(STATE_RUNNING);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// static functions
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
wxThread *wxThread::This()
|
||||
{
|
||||
return (wxThread *)pthread_getspecific(gs_keySelf);
|
||||
}
|
||||
|
||||
bool wxThread::IsMain()
|
||||
{
|
||||
return (bool)pthread_equal(pthread_self(), gs_tidMain);
|
||||
}
|
||||
|
||||
void wxThread::Yield()
|
||||
{
|
||||
#ifdef HAVE_SCHED_YIELD
|
||||
sched_yield();
|
||||
#else // !HAVE_SCHED_YIELD
|
||||
// may be it will have the desired effect?
|
||||
Sleep(0);
|
||||
#endif // HAVE_SCHED_YIELD
|
||||
}
|
||||
|
||||
void wxThread::Sleep(unsigned long milliseconds)
|
||||
{
|
||||
wxUsleep(milliseconds);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// creating thread
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
wxThread::wxThread()
|
||||
{
|
||||
// add this thread to the global list of all threads
|
||||
gs_allThreads.Add(this);
|
||||
|
||||
p_internal = new wxThreadInternal();
|
||||
}
|
||||
|
||||
wxThreadError wxThread::Create()
|
||||
{
|
||||
if (p_internal->GetState() != STATE_NEW)
|
||||
return wxTHREAD_RUNNING;
|
||||
|
||||
// set up the thread attribute: right now, we only set thread priority
|
||||
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."));
|
||||
}
|
||||
|
||||
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."),
|
||||
prio);
|
||||
}
|
||||
else
|
||||
{
|
||||
struct sched_param sp;
|
||||
pthread_attr_getschedparam(&attr, &sp);
|
||||
sp.sched_priority = min_prio +
|
||||
(p_internal->GetPriority()*(max_prio-min_prio))/100;
|
||||
pthread_attr_setschedparam(&attr, &sp);
|
||||
}
|
||||
#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
|
||||
|
||||
// create the new OS thread object
|
||||
int rc = pthread_create(&p_internal->thread_id, &attr,
|
||||
wxThreadInternal::PthreadStart, (void *)this);
|
||||
pthread_attr_destroy(&attr);
|
||||
|
||||
if ( rc != 0 )
|
||||
{
|
||||
p_internal->SetState(STATE_EXITED);
|
||||
return wxTHREAD_NO_RESOURCE;
|
||||
}
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
}
|
||||
|
||||
wxThreadError wxThread::Run()
|
||||
{
|
||||
return p_internal->Run();
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// misc accessors
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
void wxThread::SetPriority(unsigned int prio)
|
||||
{
|
||||
wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
|
||||
((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
|
||||
"invalid thread priority" );
|
||||
|
||||
wxCriticalSectionLocker lock(m_critsect);
|
||||
|
||||
switch ( p_internal->GetState() )
|
||||
{
|
||||
case STATE_NEW:
|
||||
// thread not yet started, priority will be set when it is
|
||||
p_internal->SetPriority(prio);
|
||||
break;
|
||||
|
||||
case STATE_RUNNING:
|
||||
case STATE_PAUSED:
|
||||
#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
|
||||
{
|
||||
struct sched_param sparam;
|
||||
sparam.sched_priority = prio;
|
||||
|
||||
if ( pthread_setschedparam(p_internal->GetId(),
|
||||
SCHED_OTHER, &sparam) != 0 )
|
||||
{
|
||||
wxLogError(_("Failed to set thread priority %d."), prio);
|
||||
}
|
||||
}
|
||||
#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
|
||||
break;
|
||||
|
||||
case STATE_EXITED:
|
||||
default:
|
||||
wxFAIL_MSG("impossible to set thread priority in this state");
|
||||
}
|
||||
}
|
||||
|
||||
unsigned int wxThread::GetPriority() const
|
||||
{
|
||||
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
|
||||
|
||||
return p_internal->GetPriority();
|
||||
}
|
||||
|
||||
unsigned long wxThread::GetID() const
|
||||
{
|
||||
return (unsigned long)p_internal->thread_id;
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// pause/resume
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
wxThreadError wxThread::Pause()
|
||||
{
|
||||
wxCriticalSectionLocker lock(m_critsect);
|
||||
|
||||
if ( p_internal->GetState() != STATE_RUNNING )
|
||||
{
|
||||
wxLogDebug("Can't pause thread which is not running.");
|
||||
|
||||
return wxTHREAD_NOT_RUNNING;
|
||||
}
|
||||
|
||||
p_internal->SetState(STATE_PAUSED);
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
}
|
||||
|
||||
wxThreadError wxThread::Resume()
|
||||
{
|
||||
wxCriticalSectionLocker lock(m_critsect);
|
||||
|
||||
if ( p_internal->GetState() == STATE_PAUSED )
|
||||
{
|
||||
p_internal->Resume();
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
wxLogDebug("Attempt to resume a thread which is not paused.");
|
||||
|
||||
return wxTHREAD_MISC_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// exiting thread
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
wxThread::ExitCode wxThread::Delete()
|
||||
{
|
||||
m_critsect.Enter();
|
||||
thread_state state = p_internal->GetState();
|
||||
m_critsect.Leave();
|
||||
|
||||
switch ( state )
|
||||
{
|
||||
case STATE_NEW:
|
||||
case STATE_EXITED:
|
||||
// nothing to do
|
||||
break;
|
||||
|
||||
case STATE_PAUSED:
|
||||
// resume the thread first
|
||||
Resume();
|
||||
|
||||
// fall through
|
||||
|
||||
default:
|
||||
// set the flag telling to the thread to stop and wait
|
||||
p_internal->Cancel();
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
wxThreadError wxThread::Kill()
|
||||
{
|
||||
switch ( p_internal->GetState() )
|
||||
{
|
||||
case STATE_NEW:
|
||||
case STATE_EXITED:
|
||||
return wxTHREAD_NOT_RUNNING;
|
||||
|
||||
default:
|
||||
#ifdef HAVE_PTHREAD_CANCEL
|
||||
if ( pthread_cancel(p_internal->GetId()) != 0 )
|
||||
#endif
|
||||
{
|
||||
wxLogError(_("Failed to terminate a thread."));
|
||||
|
||||
return wxTHREAD_MISC_ERROR;
|
||||
}
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
void wxThread::Exit(void *status)
|
||||
{
|
||||
// first call user-level clean up code
|
||||
OnExit();
|
||||
|
||||
// next wake up the threads waiting for us (OTOH, this function won't return
|
||||
// until someone waited for us!)
|
||||
p_internal->SignalExit();
|
||||
|
||||
p_internal->SetState(STATE_EXITED);
|
||||
|
||||
// delete both C++ thread object and terminate the OS thread object
|
||||
delete this;
|
||||
pthread_exit(status);
|
||||
}
|
||||
|
||||
// also test whether we were paused
|
||||
bool wxThread::TestDestroy()
|
||||
{
|
||||
wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
|
||||
|
||||
if ( p_internal->GetState() == STATE_PAUSED )
|
||||
{
|
||||
// leave the crit section or the other threads will stop too if they try
|
||||
// to call any of (seemingly harmless) IsXXX() functions while we sleep
|
||||
m_critsect.Leave();
|
||||
|
||||
p_internal->Pause();
|
||||
|
||||
// enter it back before it's finally left in lock object dtor
|
||||
m_critsect.Enter();
|
||||
}
|
||||
|
||||
return p_internal->WasCancelled();
|
||||
}
|
||||
|
||||
wxThread::~wxThread()
|
||||
{
|
||||
// remove this thread from the global array
|
||||
gs_allThreads.Remove(this);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// state tests
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
bool wxThread::IsRunning() const
|
||||
{
|
||||
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
|
||||
|
||||
return p_internal->GetState() == STATE_RUNNING;
|
||||
}
|
||||
|
||||
bool wxThread::IsAlive() const
|
||||
{
|
||||
wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
|
||||
|
||||
switch ( p_internal->GetState() )
|
||||
{
|
||||
case STATE_RUNNING:
|
||||
case STATE_PAUSED:
|
||||
return TRUE;
|
||||
|
||||
default:
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// wxThreadModule
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
class wxThreadModule : public wxModule
|
||||
{
|
||||
public:
|
||||
virtual bool OnInit();
|
||||
virtual void OnExit();
|
||||
|
||||
private:
|
||||
DECLARE_DYNAMIC_CLASS(wxThreadModule)
|
||||
};
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
|
||||
|
||||
bool wxThreadModule::OnInit()
|
||||
{
|
||||
if ( pthread_key_create(&gs_keySelf, NULL /* dtor function */) != 0 )
|
||||
{
|
||||
wxLogError(_("Thread module initialization failed: "
|
||||
"failed to create pthread 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" );
|
||||
|
||||
// terminate any threads left
|
||||
size_t count = gs_allThreads.GetCount();
|
||||
if ( count != 0u )
|
||||
wxLogDebug("Some threads were not terminated by the application.");
|
||||
|
||||
for ( size_t n = 0u; n < count; n++ )
|
||||
{
|
||||
gs_allThreads[n]->Delete();
|
||||
}
|
||||
|
||||
// destroy GUI mutex
|
||||
gs_mutexGui->Unlock();
|
||||
wxThreadGuiExit();
|
||||
delete gs_mutexGui;
|
||||
|
||||
// and free TLD slot
|
||||
(void)pthread_key_delete(gs_keySelf);
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user