qthread_win.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
#include "qthread.h"
#include "qthread_p.h"
 
#include "qcoreapplication.h"
#include <private/qcoreapplication_p.h>
#include <private/qeventdispatcher_win_p.h>
#include "qloggingcategory.h"
#include "qmutex.h"
#include <private/quniquehandle_types_p.h>
 
#include <qt_windows.h>
 
#ifndef _MT
#  define _MT
#endif // _MT
#include <process.h>
 
extern "C" {
// MinGW is missing the declaration of SetThreadDescription:
WINBASEAPI
HRESULT
WINAPI
SetThreadDescription(
    _In_ HANDLE hThread,
    _In_ PCWSTR lpThreadDescription
    );
}
 
#ifndef THREAD_POWER_THROTTLING_EXECUTION_SPEED
#define THREAD_POWER_THROTTLING_EXECUTION_SPEED 0x1
#define THREAD_POWER_THROTTLING_CURRENT_VERSION 1
 
typedef struct _THREAD_POWER_THROTTLING_STATE {
    ULONG Version;
    ULONG ControlMask;
    ULONG StateMask;
} THREAD_POWER_THROTTLING_STATE;
#endif
 
#ifndef CREATE_WAITABLE_TIMER_HIGH_RESOLUTION
#define CREATE_WAITABLE_TIMER_HIGH_RESOLUTION 0x2
#endif
 
QT_BEGIN_NAMESPACE
 
Q_STATIC_LOGGING_CATEGORY(lcQThread, "qt.core.thread", QtWarningMsg)
 
#if QT_CONFIG(thread)
 
Q_CONSTINIT static thread_local QThreadData *currentThreadData = nullptr;
 
static void deref_current_thread_data(QThreadData *data);
static void destroy_current_thread_data(void *p)
{
    QThreadData *data = static_cast<QThreadData *>(p);
    QThread *thread = data->thread.loadAcquire();
 
    if (data->isAdopted) {
        // If this is an adopted thread, then QThreadData owns the QThread and
        // this is very likely the last reference. These pointers cannot be
        // null and there is no race.
        QThreadPrivate *thread_p = static_cast<QThreadPrivate *>(QObjectPrivate::get(thread));
        thread_p->finish();
    } else {
        // We may be racing the QThread destructor in another thread and it may
        // have begun destruction; we must not dereference the QThread pointer.
    }
 
    deref_current_thread_data(data);
}
 
// static
void deref_current_thread_data(QThreadData *data)
{
    // the QThread object may still have a reference, so this may not delete
    data->deref();
 
    // ... but we must reset it to zero before returning so we aren't
    // leaving a dangling pointer.
    currentThreadData = nullptr;
}
 
static QThreadData *get_thread_data()
{
    return currentThreadData;
}
 
static void set_thread_data(QThreadData *data) noexcept
{
    if (data) {
        struct Cleanup {
            Cleanup() { QThreadStoragePrivate::init(); }
            ~Cleanup() { destroy_current_thread_data(currentThreadData); }
        };
        static thread_local Cleanup currentThreadCleanup;
    }
    currentThreadData = data;
}
 
/*
    QThreadData
*/
void QThreadData::clearCurrentThreadData()
{
    set_thread_data(nullptr);
}
 
QThreadData *QThreadData::currentThreadData() noexcept
{
    return get_thread_data();
}
 
QThreadData *QThreadData::createCurrentThreadData()
{
    Q_ASSERT(!currentThreadData());
 
    QThreadData *data = new QThreadData();
 
    // This needs to be called prior to new QAdoptedThread() to avoid
    // recursion (see qobject.cpp).
    set_thread_data(data);
 
    QT_TRY {
        data->thread.storeRelease(new QAdoptedThread(data));
    } QT_CATCH(...) {
        deref_current_thread_data(data);
        QT_RETHROW;
    }
    return data;
}
 
void QAdoptedThread::init()
{
    d_func()->handle = GetCurrentThread();
}
 
/**************************************************************************
 ** QThreadPrivate
 *************************************************************************/
 
#endif // QT_CONFIG(thread)
 
QAbstractEventDispatcher *QThreadPrivate::createEventDispatcher(QThreadData *data)
{
    Q_UNUSED(data);
    return new QEventDispatcherWin32;
}
 
#if QT_CONFIG(thread)
 
unsigned int __stdcall QT_ENSURE_STACK_ALIGNED_FOR_SSE QThreadPrivate::start(void *arg) noexcept
{
    QThread *thr = reinterpret_cast<QThread *>(arg);
    QThreadData *data = QThreadData::get2(thr);
 
    data->ref();
    set_thread_data(data);
    data->threadId.storeRelaxed(QThread::currentThreadId());
 
    // If a QThread is restarted, reuse the QBindingStatus, too
    data->reuseBindingStatusForNewNativeThread();
 
    QThread::setTerminationEnabled(false);
 
    {
        QMutexLocker locker(&thr->d_func()->mutex);
        data->quitNow = thr->d_func()->exited;
 
        if (thr->d_func()->serviceLevel != QThread::QualityOfService::Auto)
            thr->d_func()->setQualityOfServiceLevel(thr->d_func()->serviceLevel);
    }
 
    data->ensureEventDispatcher();
    data->eventDispatcher.loadRelaxed()->startingUp();
 
    // sets the name of the current thread.
    QString threadName = std::exchange(thr->d_func()->objectName, {});
    if (Q_LIKELY(threadName.isEmpty()))
        threadName = QString::fromUtf8(thr->metaObject()->className());
#ifndef QT_WIN_SERVER_2016_COMPAT
    SetThreadDescription(GetCurrentThread(), reinterpret_cast<const wchar_t *>(threadName.utf16()));
#else
    HMODULE kernelbase = GetModuleHandleW(L"kernelbase.dll");
    if (kernelbase != NULL) {
        typedef HRESULT (WINAPI *DESCFUNC)(HANDLE, PCWSTR);
 
        DESCFUNC setThreadDescription =
            (DESCFUNC)GetProcAddress(kernelbase, "SetThreadDescription");
        if (setThreadDescription != NULL) {
            setThreadDescription(GetCurrentThread(),
                                 reinterpret_cast<const wchar_t *>(threadName.utf16()));
        }
    }
#endif
 
    emit thr->started(QThread::QPrivateSignal());
    QThread::setTerminationEnabled(true);
    thr->run();
 
    thr->d_func()->finish();
    return 0;
}
 
void QThreadPrivate::setQualityOfServiceLevel(QThread::QualityOfService qosLevel)
{
    Q_Q(QThread);
    serviceLevel = qosLevel;
 
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN10_RS3)
    qCDebug(lcQThread) << "Setting thread QoS class to" << qosLevel << "for thread" << q;
 
    THREAD_POWER_THROTTLING_STATE state;
    memset(&state, 0, sizeof(state));
    state.Version = THREAD_POWER_THROTTLING_CURRENT_VERSION;
 
    switch (qosLevel) {
    case QThread::QualityOfService::Auto:
        state.ControlMask = 0; // Unset control of QoS
        state.StateMask = 0;
        break;
    case QThread::QualityOfService::Eco:
        state.ControlMask = THREAD_POWER_THROTTLING_EXECUTION_SPEED;
        state.StateMask = THREAD_POWER_THROTTLING_EXECUTION_SPEED;
        break;
    case QThread::QualityOfService::High:
        state.ControlMask = THREAD_POWER_THROTTLING_EXECUTION_SPEED;
        state.StateMask = 0; // Ask to disable throttling
        break;
    }
    if (!SetThreadInformation(::GetCurrentThread(), THREAD_INFORMATION_CLASS::ThreadPowerThrottling,
                              &state, sizeof(state))) {
        qErrnoWarning("Failed to set thread power throttling state");
    }
#endif
}
 
/*
    For regularly terminating threads, this will be called and executed by the thread as the
    last code before the thread exits. In that case, \a arg is the current QThread.
 
    However, this function will also be called by QThread::terminate (as well as wait() and
    setTerminationEnabled) to give Qt a chance to update the terminated thread's state and
    process pending DeleteLater events for objects that live in the terminated thread. And for
    adopted thread, this method is called by the thread watcher.
 
    In those cases, \a arg will not be the current thread.
*/
void QThreadPrivate::finish(bool lockAnyway) noexcept
{
    QThreadPrivate *d = this;
    QThread *thr = q_func();
 
    QMutexLocker locker(lockAnyway ? &d->mutex : nullptr);
    d->threadState = QThreadPrivate::Finishing;
    d->priority = QThread::InheritPriority;
    if (lockAnyway)
        locker.unlock();
    emit thr->finished(QThread::QPrivateSignal());
    QCoreApplicationPrivate::sendPostedEvents(nullptr, QEvent::DeferredDelete, d->data);
    QThreadStoragePrivate::finish(&d->data->tls);
    if (lockAnyway)
        locker.relock();
 
    QAbstractEventDispatcher *eventDispatcher = d->data->eventDispatcher.loadRelaxed();
    if (eventDispatcher) {
        d->data->eventDispatcher = 0;
        if (lockAnyway)
            locker.unlock();
        eventDispatcher->closingDown();
        delete eventDispatcher;
        if (lockAnyway)
            locker.relock();
    }
 
    d->threadState = QThreadPrivate::Finished;
    d->interruptionRequested.store(false, std::memory_order_relaxed);
 
    if (!d->waiters) {
        CloseHandle(d->handle);
        d->handle = 0;
    }
}
 
/**************************************************************************
 ** QThread
 *************************************************************************/
 
Qt::HANDLE QThread::currentThreadIdImpl() noexcept
{
    return reinterpret_cast<Qt::HANDLE>(quintptr(GetCurrentThreadId()));
}
 
int QThread::idealThreadCount() noexcept
{
    // Since Windows 11 & Server 2022, the process defaults to affinity to all
    // processor groups, even though each thread is limited to a specific
    // processor group. Prior to that, the application starts with affinity to
    // a specific group but the process becomes multi-group if the application
    // changes any thread's affinity to another group.
    //
    // https://learn.microsoft.com/en-us/windows/win32/procthread/processor-groups#behavior-starting-with-windows-11-and-windows-server-2022
    auto countArray = [](QSpan<const USHORT> groups) {
        int total = 0;
        for (USHORT group : groups)
            total += GetActiveProcessorCount(group);
        return total;
    };
 
    // Typical case: all but the largest systems will fit this array
    // Note: this API has been around since Windows 7.
    USHORT groups[16];
    USHORT groupCount = std::size(groups);
    if (Q_LIKELY(GetProcessGroupAffinity(HANDLE(-1), &groupCount, groups))) {
        return countArray({ groups, groupCount });
    } else if (groupCount > std::size(groups)) {
        // use a larger buffer
        auto buffer = static_cast<USHORT *>(alloca(sizeof(USHORT) * groupCount));
        if (GetProcessGroupAffinity(HANDLE(-1), &groupCount, buffer))
            return countArray({ buffer, groupCount });
    }
 
    // The new API failed, for some reason (it shouldn't have!). Fall back to
    // the oldest of APIs. Note this may be limited to 64 logical processors.
    SYSTEM_INFO sysinfo;
    GetSystemInfo(&sysinfo);
    return sysinfo.dwNumberOfProcessors;
}
 
void QThread::yieldCurrentThread()
{
    SwitchToThread();
}
 
#endif // QT_CONFIG(thread)
 
void QThread::sleep(std::chrono::nanoseconds nsecs)
{
    using namespace std::chrono;
    if (nsecs < 2ms) {
        QUniqueWin32NullHandle waitableTimerHandle;
        waitableTimerHandle.reset(CreateWaitableTimerEx(
                nullptr, nullptr, CREATE_WAITABLE_TIMER_HIGH_RESOLUTION, TIMER_ALL_ACCESS));
        if (waitableTimerHandle) {
            using namespace std::chrono_literals;
            // SetWaitableTimerEx's uses intervals of 100ns (0.1µs)
            using hundredsOfNano = std::ratio<1, 10'000'000>;
            using hundredsOfNanoseconds = std::chrono::duration<long long, hundredsOfNano>;
            const auto ticks100ns = duration_cast<hundredsOfNanoseconds>(nsecs);
            LARGE_INTEGER i;
            // Negate to make it a relative timeout:
            i.QuadPart = std::min(-(ticks100ns.count()), -1ll);
            BOOL timerResult = SetWaitableTimerEx(
                    waitableTimerHandle.get(), &i,
                    0, // not periodic
                    nullptr, nullptr, // no callback
                    nullptr, // no wake context / don't wake from sleep
                    0); // lowest tolerated delay
 
            if (timerResult == TRUE) {
                if (WaitForSingleObject(waitableTimerHandle.get(), INFINITE) == ERROR_SUCCESS)
                    return;
            }
        }
    }
    // Fallback:
    ::Sleep(DWORD(duration_cast<milliseconds>(nsecs).count()));
}
 
void QThread::sleep(unsigned long secs)
{
    ::Sleep(secs * 1000);
}
 
void QThread::msleep(unsigned long msecs)
{
    ::Sleep(msecs);
}
 
void QThread::usleep(unsigned long usecs)
{
    sleep(std::chrono::microseconds(usecs));
}
 
#if QT_CONFIG(thread)
 
void QThread::start(Priority priority)
{
    Q_D(QThread);
    QMutexLocker locker(&d->mutex);
 
    if (d->threadState == QThreadPrivate::Finishing) {
        locker.unlock();
        wait();
        locker.relock();
    }
 
    if (d->threadState == QThreadPrivate::Running)
        return;
 
    // avoid interacting with the binding system
    d->objectName = d->extraData ? d->extraData->objectName.valueBypassingBindings()
                                 : QString();
    d->threadState = QThreadPrivate::Running;
    d->exited = false;
    d->returnCode = 0;
    d->interruptionRequested.store(false, std::memory_order_relaxed);
 
    /*
      NOTE: we create the thread in the suspended state, set the
      priority and then resume the thread.
 
      since threads are created with normal priority by default, we
      could get into a case where a thread (with priority less than
      NormalPriority) tries to create a new thread (also with priority
      less than NormalPriority), but the newly created thread preempts
      its 'parent' and runs at normal priority.
    */
#if defined(Q_CC_MSVC) && !defined(_DLL)
    // MSVC -MT or -MTd build
    d->handle = (Qt::HANDLE) _beginthreadex(NULL, d->stackSize, QThreadPrivate::start,
                                            this, CREATE_SUSPENDED, nullptr);
#else
    // MSVC -MD or -MDd or MinGW build
    d->handle = CreateThread(nullptr, d->stackSize,
                             reinterpret_cast<LPTHREAD_START_ROUTINE>(QThreadPrivate::start),
                             this, CREATE_SUSPENDED, nullptr);
#endif
 
    if (!d->handle) {
        qErrnoWarning("QThread::start: Failed to create thread");
        d->threadState = QThreadPrivate::NotStarted;
        return;
    }
 
    int prio;
    d->priority = priority;
    switch (priority) {
    case IdlePriority:
        prio = THREAD_PRIORITY_IDLE;
        break;
 
    case LowestPriority:
        prio = THREAD_PRIORITY_LOWEST;
        break;
 
    case LowPriority:
        prio = THREAD_PRIORITY_BELOW_NORMAL;
        break;
 
    case NormalPriority:
        prio = THREAD_PRIORITY_NORMAL;
        break;
 
    case HighPriority:
        prio = THREAD_PRIORITY_ABOVE_NORMAL;
        break;
 
    case HighestPriority:
        prio = THREAD_PRIORITY_HIGHEST;
        break;
 
    case TimeCriticalPriority:
        prio = THREAD_PRIORITY_TIME_CRITICAL;
        break;
 
    case InheritPriority:
    default:
        prio = GetThreadPriority(GetCurrentThread());
        break;
    }
 
    if (!SetThreadPriority(d->handle, prio)) {
        qErrnoWarning("QThread::start: Failed to set thread priority");
    }
 
    if (ResumeThread(d->handle) == (DWORD) -1) {
        qErrnoWarning("QThread::start: Failed to resume new thread");
    }
}
 
void QThread::terminate()
{
    Q_D(QThread);
    QMutexLocker locker(&d->mutex);
    if (d->threadState != QThreadPrivate::Running)
        return;
    if (!d->terminationEnabled) {
        d->terminatePending = true;
        return;
    }
 
    TerminateThread(d->handle, 0);
    d->finish(false);
}
 
bool QThreadPrivate::wait(QMutexLocker<QMutex> &locker, QDeadlineTimer deadline)
{
    Q_ASSERT(threadState != QThreadPrivate::Finished);
    Q_ASSERT(locker.isLocked());
    QThreadPrivate *d = this;
 
    ++d->waiters;
    locker.mutex()->unlock();
 
    bool ret = false;
    switch (WaitForSingleObject(d->handle, deadline.remainingTime())) {
    case WAIT_OBJECT_0:
        ret = true;
        break;
    case WAIT_FAILED:
        qErrnoWarning("QThread::wait: Thread wait failure");
        break;
    case WAIT_ABANDONED:
    case WAIT_TIMEOUT:
    default:
        break;
    }
 
    locker.mutex()->lock();
    --d->waiters;
 
    if (ret && d->threadState < QThreadPrivate::Finished) {
        // thread was terminated by someone else
 
        d->finish(false);
    }
 
    if (d->threadState == QThreadPrivate::Finished && !d->waiters) {
        CloseHandle(d->handle);
        d->handle = 0;
    }
 
    return ret;
}
 
void QThread::setTerminationEnabled(bool enabled)
{
    QThread *thr = currentThread();
    Q_ASSERT_X(thr != 0, "QThread::setTerminationEnabled()",
               "Current thread was not started with QThread.");
    QThreadPrivate *d = thr->d_func();
    QMutexLocker locker(&d->mutex);
    d->terminationEnabled = enabled;
    if (enabled && d->terminatePending) {
        d->finish(false);
        locker.unlock(); // don't leave the mutex locked!
        _endthreadex(0);
    }
}
 
// Caller must hold the mutex
void QThreadPrivate::setPriority(QThread::Priority threadPriority)
{
    // copied from start() with a few modifications:
 
    int prio;
    priority = threadPriority;
    switch (threadPriority) {
    case QThread::IdlePriority:
        prio = THREAD_PRIORITY_IDLE;
        break;
 
    case QThread::LowestPriority:
        prio = THREAD_PRIORITY_LOWEST;
        break;
 
    case QThread::LowPriority:
        prio = THREAD_PRIORITY_BELOW_NORMAL;
        break;
 
    case QThread::NormalPriority:
        prio = THREAD_PRIORITY_NORMAL;
        break;
 
    case QThread::HighPriority:
        prio = THREAD_PRIORITY_ABOVE_NORMAL;
        break;
 
    case QThread::HighestPriority:
        prio = THREAD_PRIORITY_HIGHEST;
        break;
 
    case QThread::TimeCriticalPriority:
        prio = THREAD_PRIORITY_TIME_CRITICAL;
        break;
 
    default:
        return;
    }
 
    if (!SetThreadPriority(handle, prio)) {
        qErrnoWarning("QThread::setPriority: Failed to set thread priority");
    }
}
 
#endif // QT_CONFIG(thread)
 
QT_END_NAMESPACE