// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "thread.h"
#endif
#include "wx/thread.h"
#ifdef __WXMAC__
-#if TARGET_API_MAC_OSX
+#ifdef __DARWIN__
#include <CoreServices/CoreServices.h>
#else
#include <DriverServices.h>
#include <Multiprocessing.h>
-#include <math.h>
+#include "wx/math.h"
#endif
#include "wx/mac/uma.h"
#endif
to use two indices one for each 32 bit part as the MP implementation is limited
to longs.
- I have two implementations for mutexes :
+ I have three implementations for mutexes :
version A based on a binary semaphore, problem - not reentrant, version B based
on a critical region, allows for reentrancy, performance implications not
- yet tested
+ yet tested, and third a plain pthreads implementation
The same for condition internal, one implementation by Aj Lavin and the other one
copied from the thrimpl.cpp which I assume has been more broadly tested, I've just
replaced the interlock increment with the appropriate PPC calls
*/
+// ----------------------------------------------------------------------------
+// wxCriticalSection
+// ----------------------------------------------------------------------------
+
+wxCriticalSection::wxCriticalSection()
+{
+ MPCreateCriticalRegion( (MPCriticalRegionID*) &m_critRegion ) ;
+}
+
+wxCriticalSection::~wxCriticalSection()
+{
+ MPDeleteCriticalRegion( (MPCriticalRegionID) m_critRegion ) ;
+}
+
+void wxCriticalSection::Enter()
+{
+ MPEnterCriticalRegion( (MPCriticalRegionID) m_critRegion , kDurationForever ) ;
+}
+
+void wxCriticalSection::Leave()
+{
+ MPExitCriticalRegion((MPCriticalRegionID) m_critRegion ) ;
+}
+
// ----------------------------------------------------------------------------
// wxMutex implementation
// ----------------------------------------------------------------------------
MPQueueID m_notifyQueueId; // its notification queue
wxThreadState m_state; // see wxThreadState enum
- int m_prio; // in wxWindows units: from 0 to 100
+ int m_prio; // in wxWidgets units: from 0 to 100
// this flag is set when the thread should terminate
bool m_cancelled;
if ( m_tid)
{
// Mac priorities range from 1 to 10,000, with a default of 100.
- // wxWindows priorities range from 0 to 100 with a default of 50.
- // We can map wxWindows to Mac priorities easily by assuming
+ // wxWidgets priorities range from 0 to 100 with a default of 50.
+ // We can map wxWidgets to Mac priorities easily by assuming
// the former uses a logarithmic scale.
const unsigned int macPriority = ( int)( exp( priority / 25.0 * log( 10.0)) + 0.5);
// 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();
+ {
+ // give the thread we're waiting for chance to do the GUI call
+ // it might be in, we don't do this conditionally as the to be waited on
+ // thread might have to acquire the mutex later but before terminating
+ if ( wxGuiOwnedByMainThread() )
+ {
+ wxMutexGuiLeave();
+ }
+ }
{
wxCriticalSectionLocker lock(m_csJoinFlag);
kDurationForever);
if ( err)
{
- wxLogSysError( _( "Cannot wait on thread to exit."));
+ wxLogSysError( _( "Cannot wait for thread termination."));
rc = (void*) -1;
}
m_shouldBeJoined = FALSE;
}
}
-
- // reacquire GUI mutex
- if ( wxThread::IsMain() )
- wxMutexGuiEnter();
}
void wxThreadInternal::Pause()
bool wxThread::IsMain()
{
- return GetCurrentId() == gs_idMainThread || gs_idMainThread == kNoThreadID;
+ return GetCurrentId() == gs_idMainThread || gs_idMainThread == kInvalidID ;
}
#ifdef Yield
*rc = m_internal->GetExitCode();
}
}
- //else: can't wait for detached threads
}
return wxTHREAD_NO_ERROR;
verify_noerr( MPAllocateTaskStorageIndex( &gs_tlsForWXThread ) ) ;
// main thread's This() is NULL
- verify_noerr( MPSetTaskStorageValue( gs_tlsForWXThread , NULL ) ) ;
+ verify_noerr( MPSetTaskStorageValue( gs_tlsForWXThread , 0 ) ) ;
gs_idMainThread = wxThread::GetCurrentId() ;
{
if ( gs_critsectGui )
{
+ if ( !wxGuiOwnedByMainThread() )
+ {
+ gs_critsectGui->Enter();
+ gs_bGuiOwnedByMainThread = true;
+ }
gs_critsectGui->Leave();
delete gs_critsectGui;
gs_critsectGui = NULL;
wxASSERT_MSG( wxThread::IsMain(),
wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
+ if( !gs_critsectWaitingForGui )
+ return;
+
wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
if ( gs_nWaitingForGui == 0 )