X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ef8d96c29c73b9da8cdaa2b8b4737862c85ccc20..3f8e5072f7391db2158f44c6b9209bbb3db6eb06:/src/msw/thread.cpp diff --git a/src/msw/thread.cpp b/src/msw/thread.cpp index 35838d9a29..27b948f785 100644 --- a/src/msw/thread.cpp +++ b/src/msw/thread.cpp @@ -26,7 +26,7 @@ #endif #ifndef WX_PRECOMP - #include "wx/wx.h" +# include "wx/wx.h" #endif #if wxUSE_THREADS @@ -36,12 +36,29 @@ #include "wx/module.h" #include "wx/thread.h" +#ifdef Yield +# undef Yield +#endif + // must have this symbol defined to get _beginthread/_endthread declarations #ifndef _MT #define _MT #endif -#ifdef __VISUALC__ +#if defined(__VISUALC__) || \ + (defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)) || \ + (defined(__GNUG__) && defined(__MSVCRT__)) + +#if defined(__BORLANDC__) && !defined(__MT__) +// I can't set -tWM in the IDE (anyone?) so have to do this +#define __MT__ +#endif + +#if defined(__BORLANDC__) && !defined(__MFC_COMPAT__) +// Needed to know about _beginthreadex etc.. +#define __MFC_COMPAT__ +#endif + #include #endif @@ -99,33 +116,43 @@ static bool gs_waitingForThread = FALSE; class wxMutexInternal { public: - HANDLE p_mutex; + wxMutexInternal() + { + m_mutex = ::CreateMutex(NULL, FALSE, NULL); + if ( !m_mutex ) + { + wxLogSysError(_("Can not create mutex")); + } + } + + ~wxMutexInternal() { if ( m_mutex ) CloseHandle(m_mutex); } + +public: + HANDLE m_mutex; }; wxMutex::wxMutex() { m_internal = new wxMutexInternal; - m_internal->p_mutex = CreateMutex(NULL, FALSE, NULL); - if ( !m_internal->p_mutex ) - { - wxLogSysError(_("Can not create mutex.")); - } m_locked = 0; } wxMutex::~wxMutex() { - if (m_locked > 0) - wxLogDebug(wxT("Warning: freeing a locked mutex (%d locks)."), m_locked); - CloseHandle(m_internal->p_mutex); + if ( m_locked > 0 ) + { + wxLogDebug(_T("Warning: freeing a locked mutex (%d locks)."), m_locked); + } + + delete m_internal; } wxMutexError wxMutex::Lock() { DWORD ret; - ret = WaitForSingleObject(m_internal->p_mutex, INFINITE); + ret = WaitForSingleObject(m_internal->m_mutex, INFINITE); switch ( ret ) { case WAIT_ABANDONED: @@ -152,7 +179,7 @@ wxMutexError wxMutex::TryLock() { DWORD ret; - ret = WaitForSingleObject(m_internal->p_mutex, 0); + ret = WaitForSingleObject(m_internal->m_mutex, 0); if (ret == WAIT_TIMEOUT || ret == WAIT_ABANDONED) return wxMUTEX_BUSY; @@ -165,7 +192,7 @@ wxMutexError wxMutex::Unlock() if (m_locked > 0) m_locked--; - BOOL ret = ReleaseMutex(m_internal->p_mutex); + BOOL ret = ReleaseMutex(m_internal->m_mutex); if ( ret == 0 ) { wxLogSysError(_("Couldn't release a mutex")); @@ -363,6 +390,12 @@ private: DWORD wxThreadInternal::WinThreadStart(wxThread *thread) { + // first of all, check whether we hadn't been cancelled already + if ( thread->m_internal->GetState() == STATE_EXITED ) + { + return (DWORD)-1; + } + // store the thread object in the TLS if ( !::TlsSetValue(gs_tlsThisThread, thread) ) { @@ -426,15 +459,17 @@ bool wxThreadInternal::Create(wxThread *thread) // for compilers which have it, we should use C RTL function for thread // creation instead of Win32 API one because otherwise we will have memory // leaks if the thread uses C RTL (and most threads do) -#ifdef __VISUALC__ +#if defined(__VISUALC__) || \ + (defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)) || \ + (defined(__GNUG__) && defined(__MSVCRT__)) typedef unsigned (__stdcall *RtlThreadStart)(void *); m_hThread = (HANDLE)_beginthreadex(NULL, 0, - (RtlThreadStart) + (RtlThreadStart) wxThreadInternal::WinThreadStart, thread, CREATE_SUSPENDED, (unsigned int *)&m_tid); -#else // !VC++ +#else // compiler doesn't have _beginthreadex m_hThread = ::CreateThread ( NULL, // default security @@ -445,7 +480,7 @@ bool wxThreadInternal::Create(wxThread *thread) CREATE_SUSPENDED, // flags &m_tid // [out] thread id ); -#endif // VC++/!VC++ +#endif // _beginthreadex/CreateThread if ( m_hThread == NULL ) { @@ -515,6 +550,10 @@ bool wxThread::IsMain() return ::GetCurrentThreadId() == gs_idMainThread; } +#ifdef Yield +#undef Yield +#endif + void wxThread::Yield() { // 0 argument to Sleep() is special and means to just give away the rest of @@ -529,13 +568,111 @@ void wxThread::Sleep(unsigned long milliseconds) int wxThread::GetCPUCount() { - return -1; + SYSTEM_INFO si; + GetSystemInfo(&si); + + return si.dwNumberOfProcessors; } bool wxThread::SetConcurrency(size_t level) { + wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") ); + // ok only for the default one - return level == 0; + if ( level == 0 ) + return 0; + + // get system affinity mask first + HANDLE hProcess = ::GetCurrentProcess(); + DWORD dwProcMask, dwSysMask; + if ( ::GetProcessAffinityMask(hProcess, &dwProcMask, &dwSysMask) == 0 ) + { + wxLogLastError(_T("GetProcessAffinityMask")); + + return FALSE; + } + + // how many CPUs have we got? + if ( dwSysMask == 1 ) + { + // don't bother with all this complicated stuff - on a single + // processor system it doesn't make much sense anyhow + return level == 1; + } + + // calculate the process mask: it's a bit vector with one bit per + // processor; we want to schedule the process to run on first level + // CPUs + DWORD bit = 1; + while ( bit ) + { + if ( dwSysMask & bit ) + { + // ok, we can set this bit + dwProcMask |= bit; + + // another process added + if ( !--level ) + { + // and that's enough + break; + } + } + + // next bit + bit <<= 1; + } + + // could we set all bits? + if ( level != 0 ) + { + wxLogDebug(_T("bad level %u in wxThread::SetConcurrency()"), level); + + return FALSE; + } + + // set it: we can't link to SetProcessAffinityMask() because it doesn't + // exist in Win9x, use RT binding instead + + typedef BOOL (*SETPROCESSAFFINITYMASK)(HANDLE, DWORD); + + // can use static var because we're always in the main thread here + static SETPROCESSAFFINITYMASK pfnSetProcessAffinityMask = NULL; + + if ( !pfnSetProcessAffinityMask ) + { + HMODULE hModKernel = ::LoadLibrary(_T("kernel32")); + if ( hModKernel ) + { + pfnSetProcessAffinityMask = (SETPROCESSAFFINITYMASK) + ::GetProcAddress(hModKernel, +#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x520) + "SetProcessAffinityMask"); +#else + _T("SetProcessAffinityMask")); +#endif + } + + // we've discovered a MT version of Win9x! + wxASSERT_MSG( pfnSetProcessAffinityMask, + _T("this system has several CPUs but no " + "SetProcessAffinityMask function?") ); + } + + if ( !pfnSetProcessAffinityMask ) + { + // msg given above - do it only once + return FALSE; + } + + if ( pfnSetProcessAffinityMask(hProcess, dwProcMask) == 0 ) + { + wxLogLastError(_T("SetProcessAffinityMask")); + + return FALSE; + } + + return TRUE; } // ctor and dtor @@ -621,11 +758,29 @@ wxThreadError wxThread::Delete(ExitCode *pRc) ExitCode rc = 0; // Delete() is always safe to call, so consider all possible states - if ( IsPaused() ) + + // has the thread started to run? + bool shouldResume = FALSE; + + { + wxCriticalSectionLocker lock(m_critsect); + + if ( m_internal->GetState() == STATE_NEW ) + { + // WinThreadStart() will see it and terminate immediately + m_internal->SetState(STATE_EXITED); + + shouldResume = TRUE; + } + } + + // is the thread paused? + if ( shouldResume || IsPaused() ) Resume(); HANDLE hThread = m_internal->GetHandle(); + // does is still run? if ( IsRunning() ) { if ( IsMain() ) @@ -776,7 +931,9 @@ void wxThread::Exit(ExitCode status) delete this; } -#ifdef __VISUALC__ +#if defined(__VISUALC__) || \ + (defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)) || \ + (defined(__GNUG__) && defined(__MSVCRT__)) _endthreadex((unsigned)status); #else // !VC++ ::ExitThread((DWORD)status);