qthread_unix.cpp File Reference

#include "qthread.h"
#include "qplatformdefs.h"
#include <private/qcoreapplication_p.h>
#include "../kernel/qeventdispatcher_glib_p.h"
#include <private/qeventdispatcher_unix_p.h>
#include "qthreadstorage.h"
#include "qthread_p.h"
#include "qdebug.h"
#include <sched.h>
#include <errno.h>
#include <CoreServices/CoreServices.h>
#include <sys/prctl.h>

Go to the source code of this file.

Macros
#define	QT_HAS_THREAD_PRIORITY_SCHEDULING
#define	SCHED_IDLE   5

Typedefs
typedef void *(*	QtThreadCallback) (void *)

Enumerations
enum	{ ThreadPriorityResetFlag = 0x80000000 }

Functions
static bool	calculateUnixPriority (int priority, int *sched_policy, int *sched_priority)
static void	clear_thread_data ()
static void	create_current_thread_data_key ()
static void	destroy_current_thread_data (void *p)
static void	destroy_current_thread_data_key ()
static QThreadData *	get_thread_data ()
static void	set_thread_data (QThreadData *data)
static void	setCurrentThreadName (pthread_t threadId, const char *name)
static void	thread_sleep (struct timespec *ti)

Variables
static pthread_key_t	current_thread_data_key
static pthread_once_t	current_thread_data_once = PTHREAD_ONCE_INIT

Macro Definition Documentation

QT_HAS_THREAD_PRIORITY_SCHEDULING

#define QT_HAS_THREAD_PRIORITY_SCHEDULING

Definition at line 107 of file qthread_unix.cpp.

SCHED_IDLE

#define SCHED_IDLE   5

Definition at line 103 of file qthread_unix.cpp.

Referenced by calculateUnixPriority(), and QThread::setPriority().

Typedef Documentation

QtThreadCallback

typedef void*(* QtThreadCallback) (void *)

Definition at line 266 of file qthread_unix.cpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
ThreadPriorityResetFlag

Definition at line 115 of file qthread_unix.cpp.

{ ThreadPriorityResetFlag = 0x80000000 };

Function Documentation

calculateUnixPriority()

static bool calculateUnixPriority ( int  priority, int *  sched_policy, int *  sched_priority  )

static

Definition at line 537 of file qthread_unix.cpp.

Referenced by QThread::setPriority(), and QThread::start().

{
#ifdef Q_OS_QNX
    // without Round Robin drawn intensive apps will hog the cpu
    // and make the system appear frozen
   *sched_policy = SCHED_RR;
#endif
#ifdef SCHED_IDLE
    if (priority == QThread::IdlePriority) {
        *sched_policy = SCHED_IDLE;
        *sched_priority = 0;
        return true;
    }
    const int lowestPriority = QThread::LowestPriority;
#else
    const int lowestPriority = QThread::IdlePriority;
#endif
    const int highestPriority = QThread::TimeCriticalPriority;

    int prio_min;
    int prio_max;
#if defined(Q_OS_VXWORKS) && defined(VXWORKS_DKM)
    // for other scheduling policies than SCHED_RR or SCHED_FIFO
    prio_min = SCHED_FIFO_LOW_PRI;
    prio_max = SCHED_FIFO_HIGH_PRI;

    if ((*sched_policy == SCHED_RR) || (*sched_policy == SCHED_FIFO))
#endif
    {
    prio_min = sched_get_priority_min(*sched_policy);
    prio_max = sched_get_priority_max(*sched_policy);
    }

    if (prio_min == -1 || prio_max == -1)
        return false;

    int prio;
    // crudely scale our priority enum values to the prio_min/prio_max
    prio = ((priority - lowestPriority) * (prio_max - prio_min) / highestPriority) + prio_min;
    prio = qMax(prio_min, qMin(prio_max, prio));

    *sched_priority = prio;
    return true;
}

clear_thread_data()

static void clear_thread_data ( )

static

Definition at line 204 of file qthread_unix.cpp.

Referenced by QThreadData::clearCurrentThreadData(), and QThreadData::current().

{
#ifdef HAVE_TLS
    currentThreadData = 0;
#endif
    pthread_setspecific(current_thread_data_key, 0);
}

create_current_thread_data_key()

static void create_current_thread_data_key ( )

static

Definition at line 165 of file qthread_unix.cpp.

Referenced by destroy_current_thread_data_key(), get_thread_data(), and set_thread_data().

{
    pthread_key_create(&current_thread_data_key, destroy_current_thread_data);
}

destroy_current_thread_data()

static void destroy_current_thread_data ( void *  p )

static

Definition at line 131 of file qthread_unix.cpp.

Referenced by create_current_thread_data_key().

{
#if defined(Q_OS_VXWORKS)
    // Calling setspecific(..., 0) sets the value to 0 for ALL threads.
    // The 'set to 1' workaround adds a bit of an overhead though,
    // since this function is called twice now.
    if (p == (void *)1)
        return;
#endif
    // POSIX says the value in our key is set to zero before calling
    // this destructor function, so we need to set it back to the
    // right value...
    pthread_setspecific(current_thread_data_key, p);
    QThreadData *data = static_cast<QThreadData *>(p);
    if (data->isAdopted) {
        QThread *thread = data->thread;
        Q_ASSERT(thread);
        QThreadPrivate *thread_p = static_cast<QThreadPrivate *>(QObjectPrivate::get(thread));
        Q_ASSERT(!thread_p->finished);
        thread_p->finish(thread);
    }
    data->deref();

    // ... but we must reset it to zero before returning so we aren't
    // called again (POSIX allows implementations to call destructor
    // functions repeatedly until all values are zero)
    pthread_setspecific(current_thread_data_key,
#if defined(Q_OS_VXWORKS)
                                                 (void *)1);
#else
                                                 0);
#endif
}

destroy_current_thread_data_key()

static void destroy_current_thread_data_key ( )

static

Definition at line 170 of file qthread_unix.cpp.

{
    pthread_once(&current_thread_data_once, create_current_thread_data_key);
    pthread_key_delete(current_thread_data_key);

    // Reset current_thread_data_once in case we end up recreating
    // the thread-data in the rare case of QObject construction
    // after destroying the QThreadData.
    pthread_once_t pthread_once_init = PTHREAD_ONCE_INIT;
    current_thread_data_once = pthread_once_init;
}

get_thread_data()

static QThreadData* get_thread_data ( )

static

Definition at line 185 of file qthread_unix.cpp.

Referenced by QThreadData::current().

{
#ifdef HAVE_TLS
    return currentThreadData;
#else
    pthread_once(&current_thread_data_once, create_current_thread_data_key);
    return reinterpret_cast<QThreadData *>(pthread_getspecific(current_thread_data_key));
#endif
}

set_thread_data()

static void set_thread_data ( QThreadData *  data )

static

Definition at line 195 of file qthread_unix.cpp.

Referenced by QThreadData::current(), and QThreadPrivate::start().

{
#ifdef HAVE_TLS
    currentThreadData = data;
#endif
    pthread_once(&current_thread_data_once, create_current_thread_data_key);
    pthread_setspecific(current_thread_data_key, data);
}

setCurrentThreadName()

static void setCurrentThreadName ( pthread_t  threadId, const char *  name  )

static

Definition at line 295 of file qthread_unix.cpp.

Referenced by QThreadPrivate::start().

{
#  if defined(Q_OS_LINUX) && !defined(QT_LINUXBASE)
    Q_UNUSED(threadId);
    prctl(PR_SET_NAME, (unsigned long)name, 0, 0, 0);
#  elif (defined(Q_OS_MAC) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6)
    Q_UNUSED(threadId);
    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_6)
        pthread_setname_np(name);
#  elif defined(Q_OS_QNX)
    pthread_setname_np(threadId, name);
#  endif
}

thread_sleep()

static void thread_sleep ( struct timespec *  ti )

static

Definition at line 483 of file qthread_unix.cpp.

Referenced by QThread::msleep(), QThread::sleep(), and QThread::usleep().

{
    pthread_mutex_t mtx;
    pthread_cond_t cnd;

    pthread_mutex_init(&mtx, 0);
    pthread_cond_init(&cnd, 0);

    pthread_mutex_lock(&mtx);
    (void) pthread_cond_timedwait(&cnd, &mtx, ti);
    pthread_mutex_unlock(&mtx);

    pthread_cond_destroy(&cnd);
    pthread_mutex_destroy(&mtx);
}

Variable Documentation

current_thread_data_key

pthread_key_t current_thread_data_key

static

Definition at line 129 of file qthread_unix.cpp.

Referenced by clear_thread_data(), create_current_thread_data_key(), destroy_current_thread_data(), destroy_current_thread_data_key(), get_thread_data(), and set_thread_data().

current_thread_data_once

pthread_once_t current_thread_data_once = PTHREAD_ONCE_INIT

static

Definition at line 128 of file qthread_unix.cpp.

Referenced by destroy_current_thread_data_key(), get_thread_data(), and set_thread_data().