// we use wxFFile under Linux in GetCPUCount()
#ifdef __LINUX__
#include "wx/ffile.h"
+ // For setpriority.
+ #include <sys/time.h>
+ #include <sys/resource.h>
#endif
// ----------------------------------------------------------------------------
m_isOk = err == 0;
if ( !m_isOk )
{
- wxLogApiError("pthread_mutex_init()", err);
+ wxLogApiError( wxT("pthread_mutex_init()"), err);
}
}
int err = pthread_mutex_destroy(&m_mutex);
if ( err != 0 )
{
- wxLogApiError("pthread_mutex_destroy()", err);
+ wxLogApiError( wxT("pthread_mutex_destroy()"), err);
}
}
}
return wxSEMA_MISC_ERROR;
wxLogTrace(TRACE_SEMA,
- "Thread %ld finished waiting for semaphore, count = %u",
- wxThread::GetCurrentId(), m_count);
+ "Thread %ld finished waiting for semaphore, count = %lu",
+ wxThread::GetCurrentId(), (unsigned long)m_count);
}
m_count--;
return wxSEMA_TIMEOUT;
}
- if ( m_cond.Wait(remainingTime) != wxCOND_NO_ERROR )
+ if ( m_cond.WaitTimeout(remainingTime) != wxCOND_NO_ERROR )
return wxSEMA_MISC_ERROR;
}
m_count++;
wxLogTrace(TRACE_SEMA,
- "Thread %ld about to signal semaphore, count = %u",
- wxThread::GetCurrentId(), m_count);
-
+ "Thread %ld about to signal semaphore, count = %lu",
+ wxThread::GetCurrentId(), (unsigned long)m_count);
+
return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
: wxSEMA_MISC_ERROR;
}
};
wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."),
- GetId(), stateNames[m_state], stateNames[state]);
+ (long)GetId(), stateNames[m_state], stateNames[state]);
#endif // __WXDEBUG__
m_state = state;
{
wxThreadInternal *pthread = thread->m_internal;
- wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId());
-
+#ifdef __VMS
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), (long long)pthread->GetId());
+#else
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), (long)pthread->GetId());
+#endif
+
// associate the thread pointer with the newly created thread so that
// wxThread::This() will work
int rc = pthread_setspecific(gs_keySelf, thread);
{
// call the main entry
wxLogTrace(TRACE_THREADS, _T("Thread %ld about to enter its Entry()."),
- pthread->GetId());
-
+#ifdef __VMS
+ (long long)pthread->GetId());
+#else
+ (long)pthread->GetId());
+#endif
+
pthread->m_exitcode = thread->Entry();
wxLogTrace(TRACE_THREADS, _T("Thread %ld Entry() returned %lu."),
- pthread->GetId(), (unsigned long)pthread->m_exitcode);
-
+#ifdef __VMS
+ (long long)pthread->GetId(), (unsigned long)pthread->m_exitcode);
+#else
+ (long)pthread->GetId(), (unsigned long)pthread->m_exitcode);
+#endif
+
{
wxCriticalSectionLocker lock(thread->m_critsect);
wxMutexGuiLeave();
wxLogTrace(TRACE_THREADS,
- _T("Starting to wait for thread %ld to exit."), GetId());
-
+#ifdef __VMS
+ _T("Starting to wait for thread %ld to exit."), (long long)GetId());
+#else
+ _T("Starting to wait for thread %ld to exit."), (long)GetId());
+#endif
+
// to avoid memory leaks we should call pthread_join(), but it must only be
// done once so use a critical section to serialize the code below
{
// we're cancelled inside pthread_join(), things will almost
// certainly break - but if we disable the cancellation, we
// might deadlock
- if ( pthread_join((pthread_t)GetId(), &m_exitcode) != 0 )
+ if ( pthread_join(GetId(), &m_exitcode) != 0 )
{
// this is a serious problem, so use wxLogError and not
// wxLogDebug: it is possible to bring the system to its knees
wxCHECK_RET( m_state == STATE_PAUSED,
wxT("thread must first be paused with wxThread::Pause().") );
- wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId());
-
+#ifdef __VMS
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), (long long)GetId());
+#else
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), (long)GetId());
+#endif
+
// wait until the semaphore is Post()ed from Resume()
m_semSuspend.Wait();
}
// TestDestroy() since the last call to Pause() for example
if ( IsReallyPaused() )
{
- wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId());
-
+#ifdef __VMS
+ wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), (long long)GetId());
+#else
+ wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), (long)GetId());
+#endif
+
// wake up Pause()
m_semSuspend.Post();
else
{
wxLogTrace(TRACE_THREADS, _T("Thread %ld is not yet really paused"),
- GetId());
+#ifdef __VMS
+ (long long)GetId());
+#else
+ (long)GetId());
+#endif
}
SetState(STATE_RUNNING);
case STATE_RUNNING:
case STATE_PAUSED:
#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
+#if defined(__LINUX__)
+// On Linux, pthread_setschedparam with SCHED_OTHER does not allow
+// a priority other than 0. Instead, we use the BSD setpriority
+// which alllows us to set a 'nice' value between 20 to -20. Only
+// super user can set a value less than zero (more negative yields
+// higher priority). setpriority set the static priority of a process,
+// but this is OK since Linux is configured as a thread per process.
+ {
+ float fPrio;
+ float pSpan;
+ int iPrio;
+
+ // Map Wx priorites (WXTHREAD_MIN_PRIORITY -
+ // WXTHREAD_MAX_PRIORITY) into BSD priorities (20 - -20).
+ // Do calculation of values instead of hard coding them
+ // to make maintenance easier.
+
+ pSpan = ((float)(WXTHREAD_MAX_PRIORITY - WXTHREAD_MIN_PRIORITY)) / 2.0;
+
+ // prio starts as ................... // value => (0) >= p <= (n)
+
+ fPrio = ((float)prio) - pSpan; // value => (-n) >= p <= (+n)
+
+ fPrio = 0.0 - fPrio; // value => (+n) <= p >= (-n)
+
+ fPrio = fPrio * (20. / pSpan) + .5; // value => (20) <= p >= (-20)
+
+ iPrio = (int)fPrio;
+
+ // Clamp prio from 20 - -20;
+ iPrio = (iPrio > 20) ? 20 : iPrio;
+ iPrio = (iPrio < -20) ? -20 : iPrio;
+
+ if (setpriority(PRIO_PROCESS, 0, iPrio) == -1)
+ {
+ wxLogError(_("Failed to set thread priority %d."), prio);
+ }
+ }
+#else // __LINUX__
{
struct sched_param sparam;
sparam.sched_priority = prio;
wxLogError(_("Failed to set thread priority %d."), prio);
}
}
+#endif // __LINUX__
#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
break;
if ( nThreadsBeingDeleted > 0 )
{
- wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"),
- nThreadsBeingDeleted);
+ wxLogTrace(TRACE_THREADS,
+ _T("Waiting for %lu threads to disappear"),
+ (unsigned long)nThreadsBeingDeleted);
// have to wait until all of them disappear
gs_condAllDeleted->Wait();
size_t count = gs_allThreads.GetCount();
if ( count != 0u )
{
- wxLogDebug(wxT("%u threads were not terminated by the application."),
- count);
+ wxLogDebug(wxT("%lu threads were not terminated by the application."),
+ (unsigned long)count);
}
for ( size_t n = 0u; n < count; n++ )
gs_nThreadsBeingDeleted++;
- wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"),
- gs_nThreadsBeingDeleted,
+ wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
+ (unsigned long)gs_nThreadsBeingDeleted,
gs_nThreadsBeingDeleted == 1 ? "" : "s");
}
wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
_T("no threads scheduled for deletion, yet we delete one?") );
- wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
- gs_nThreadsBeingDeleted - 1);
+ wxLogTrace(TRACE_THREADS, _T("%lu scheduled for deletion threads left."),
+ (unsigned long)gs_nThreadsBeingDeleted - 1);
if ( !--gs_nThreadsBeingDeleted )
{
projects / wxWidgets.git / blobdiff