X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/71110b404c5cbef2175b2be645783e93d9a2b8c4..b77b87881bae2e6306366d79e7fe160334b3d4a2:/src/mac/carbon/thread.cpp diff --git a/src/mac/carbon/thread.cpp b/src/mac/carbon/thread.cpp index 88f837d669..3634a69dde 100644 --- a/src/mac/carbon/thread.cpp +++ b/src/mac/carbon/thread.cpp @@ -37,8 +37,12 @@ #ifdef __WXMAC__ #include #include "wx/mac/uma.h" +#include "wx/mac/macnotfy.h" #endif +#define INFINITE 0xFFFFFFFF + + // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -60,6 +64,7 @@ enum wxThreadState static ThreadID gs_idMainThread = kNoThreadID ; static bool gs_waitingForThread = FALSE ; +size_t g_numberOfThreads = 0; // ============================================================================ // MacOS implementation of thread classes @@ -87,38 +92,32 @@ public : class wxMutexInternal { public: - wxMutexInternal() + wxMutexInternal(wxMutexType WXUNUSED(mutexType)) { m_owner = kNoThreadID ; + m_locked = 0; } ~wxMutexInternal() { + if ( m_locked > 0 ) + { + wxLogDebug(_T("Warning: freeing a locked mutex (%ld locks)."), m_locked); + } } + bool IsOk() const { return true; } + + wxMutexError Lock() ; + wxMutexError TryLock() ; + wxMutexError Unlock(); public: ThreadID m_owner ; wxArrayLong m_waiters ; + long m_locked ; }; -wxMutex::wxMutex() -{ - m_internal = new wxMutexInternal; - - m_locked = 0; -} - -wxMutex::~wxMutex() -{ - if ( m_locked > 0 ) - { - wxLogDebug(_T("Warning: freeing a locked mutex (%d locks)."), m_locked); - } - - delete m_internal; -} - -wxMutexError wxMutex::Lock() +wxMutexError wxMutexInternal::Lock() { wxMacStCritical critical ; if ( UMASystemIsInitialized() ) @@ -128,39 +127,38 @@ wxMutexError wxMutex::Lock() err = ::MacGetCurrentThread(¤t); // if we are not the owner, add this thread to the list of waiting threads, stop this thread // and invoke the scheduler to continue executing the owner's thread - while ( m_internal->m_owner != kNoThreadID && m_internal->m_owner != current) + while ( m_owner != kNoThreadID && m_owner != current) { - m_internal->m_waiters.Add(current); - err = ::SetThreadStateEndCritical(kCurrentThreadID, kStoppedThreadState, m_internal->m_owner); + m_waiters.Add(current); + err = ::SetThreadStateEndCritical(kCurrentThreadID, kStoppedThreadState, m_owner); err = ::ThreadBeginCritical(); } - m_internal->m_owner = current; + m_owner = current; } m_locked++; return wxMUTEX_NO_ERROR; } -wxMutexError wxMutex::TryLock() +wxMutexError wxMutexInternal::TryLock() { wxMacStCritical critical ; if ( UMASystemIsInitialized() ) { - OSErr err ; ThreadID current = kNoThreadID; ::MacGetCurrentThread(¤t); // if we are not the owner, give an error back - if ( m_internal->m_owner != kNoThreadID && m_internal->m_owner != current ) + if ( m_owner != kNoThreadID && m_owner != current ) return wxMUTEX_BUSY; - m_internal->m_owner = current; + m_owner = current; } m_locked++; return wxMUTEX_NO_ERROR; } -wxMutexError wxMutex::Unlock() +wxMutexError wxMutexInternal::Unlock() { if ( UMASystemIsInitialized() ) { @@ -171,20 +169,20 @@ wxMutexError wxMutex::Unlock() m_locked--; // this mutex is not owned by anybody anmore - m_internal->m_owner = kNoThreadID; + m_owner = kNoThreadID; // now pass on to the first waiting thread ThreadID firstWaiting = kNoThreadID; bool found = false; - while (!m_internal->m_waiters.IsEmpty() && !found) + while (!m_waiters.IsEmpty() && !found) { - firstWaiting = m_internal->m_waiters[0]; + firstWaiting = m_waiters[0]; err = ::SetThreadState(firstWaiting, kReadyThreadState, kNoThreadID); // in case this was not successful (dead thread), we just loop on and reset the id found = (err != threadNotFoundErr); if ( !found ) firstWaiting = kNoThreadID ; - m_internal->m_waiters.RemoveAt(0) ; + m_waiters.RemoveAt(0) ; } // now we have a valid firstWaiting thread, which has been scheduled to run next, just end the // critical section and invoke the scheduler @@ -198,10 +196,58 @@ wxMutexError wxMutex::Unlock() return wxMUTEX_NO_ERROR; } +// -------------------------------------------------------------------------- +// wxSemaphore +// -------------------------------------------------------------------------- + +// TODO not yet implemented + +class wxSemaphoreInternal +{ +public: + wxSemaphoreInternal(int initialcount, int maxcount); + ~wxSemaphoreInternal(); + + bool IsOk() const { return true ; } + + wxSemaError Wait() { return WaitTimeout(INFINITE); } + wxSemaError TryWait() { return WaitTimeout(0); } + wxSemaError WaitTimeout(unsigned long milliseconds); + + wxSemaError Post(); + +private: +}; + +wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount) +{ + if ( maxcount == 0 ) + { + // make it practically infinite + maxcount = INT_MAX; + } +} + +wxSemaphoreInternal::~wxSemaphoreInternal() +{ +} + +wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds) +{ + return wxSEMA_MISC_ERROR; +} + +wxSemaError wxSemaphoreInternal::Post() +{ + return wxSEMA_MISC_ERROR; +} + // ---------------------------------------------------------------------------- // wxCondition implementation // ---------------------------------------------------------------------------- +// TODO this is not yet completed + class wxConditionInternal { public: @@ -213,17 +259,24 @@ public: { } - bool Wait(unsigned long msectimeout) + bool IsOk() const { return m_mutex.IsOk() ; } + + wxCondError Wait() + { + return WaitTimeout(0xFFFFFFFF ); + } + + wxCondError WaitTimeout(unsigned long msectimeout) { wxMacStCritical critical ; if ( m_excessSignals > 0 ) { --m_excessSignals ; - return TRUE ; + return wxCOND_NO_ERROR ; } else if ( msectimeout == 0 ) { - return FALSE ; + return wxCOND_MISC_ERROR ; } else { @@ -238,11 +291,18 @@ public: return rc != WAIT_TIMEOUT; */ - return TRUE ; + return wxCOND_NO_ERROR ; + } + wxCondError Signal() + { + wxMacStCritical critical ; + return wxCOND_NO_ERROR; } - void Signal() + + wxCondError Broadcast() { wxMacStCritical critical ; + return wxCOND_NO_ERROR; } wxArrayLong m_waiters ; @@ -250,47 +310,6 @@ public: wxMutex& m_mutex; }; -wxCondition::wxCondition(wxMutex& mutex) -{ - m_internal = new wxConditionInternal(mutex); -} - -wxCondition::~wxCondition() -{ - delete m_internal; -} - -void wxCondition::Wait() -{ - (void)m_internal->Wait(0xFFFFFFFFL); -} - -bool wxCondition::Wait(unsigned long timeout_millis) -{ - return m_internal->Wait(timeout_millis); -} - -void wxCondition::Signal() -{ - // set the event to signaled: if a thread is already waiting on it, it will - // be woken up, otherwise the event will remain in the signaled state until - // someone waits on it. In any case, the system will return it to a non - // signalled state afterwards. If multiple threads are waiting, only one - // will be woken up. - m_internal->Signal() ; -} - -void wxCondition::Broadcast() -{ - // this works because all these threads are already waiting and so each - // SetEvent() inside Signal() is really a PulseEvent() because the event - // state is immediately returned to non-signaled - for ( int i = 0; i < m_internal->m_waiters.Count(); i++ ) - { - Signal(); - } -} - // ---------------------------------------------------------------------------- // wxCriticalSection implementation // ---------------------------------------------------------------------------- @@ -417,6 +436,8 @@ bool wxThreadInternal::Create(wxThread *thread, unsigned int stackSize) SetPriority(m_priority); } + m_state = STATE_NEW; + return TRUE; } @@ -477,7 +498,7 @@ wxThread *wxThread::This() err = MacGetCurrentThread( ¤t ) ; - for ( int i = 0 ; i < s_threads.Count() ; ++i ) + for ( size_t i = 0 ; i < s_threads.Count() ; ++i ) { if ( ( (wxThread*) s_threads[i] )->GetId() == current ) return (wxThread*) s_threads[i] ; @@ -507,11 +528,11 @@ void wxThread::Yield() void wxThread::Sleep(unsigned long milliseconds) { - clock_t start = clock() ; - do - { - YieldToAnyThread() ; - } while( clock() - start < milliseconds / CLOCKS_PER_SEC ) ; + clock_t start = clock(); + do + { + YieldToAnyThread(); + } while( clock() - start < milliseconds * CLOCKS_PER_SEC / 1000.0 ) ; } int wxThread::GetCPUCount() @@ -551,6 +572,7 @@ bool wxThread::SetConcurrency(size_t level) wxThread::wxThread(wxThreadKind kind) { + g_numberOfThreads++; m_internal = new wxThreadInternal(); m_isDetached = kind == wxTHREAD_DETACHED; @@ -559,8 +581,22 @@ wxThread::wxThread(wxThreadKind kind) wxThread::~wxThread() { + if (g_numberOfThreads>0) + { + g_numberOfThreads--; + } +#ifdef __WXDEBUG__ + else + { + wxFAIL_MSG(wxT("More threads deleted than created.")); + } +#endif + s_threads.Remove( (void*) this ) ; - delete m_internal; + if (m_internal != NULL) { + delete m_internal; + m_internal = NULL; + } } // create/start thread @@ -695,13 +731,6 @@ wxThreadError wxThread::Delete(ExitCode *pRc) } } - // if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) ) - { - wxLogLastError("GetExitCodeThread"); - - rc = (ExitCode)-1; - } - if ( IsDetached() ) { // if the thread exits normally, this is done in WinThreadStart, but in @@ -711,9 +740,6 @@ wxThreadError wxThread::Delete(ExitCode *pRc) delete this; } - // wxASSERT_MSG( (DWORD)rc != STILL_ACTIVE, - // wxT("thread must be already terminated.") ); - if ( pRc ) *pRc = rc; @@ -833,7 +859,7 @@ bool wxThreadModule::OnInit() #endif if ( !hasThreadManager ) { - wxMessageBox( "Error" , "Thread Support is not available on this System" , wxOK ) ; + wxLogSysError( wxT("Thread Support is not available on this System") ); return FALSE ; } @@ -880,6 +906,6 @@ bool WXDLLEXPORT wxIsWaitingForThread() return false ; } -#endif // wxUSE_THREADS +#include "wx/thrimpl.cpp" -// vi:sts=4:sw=4:et +#endif // wxUSE_THREADS