Basic Linux and Windows Thread Prioritisation for worker threads

[hmelder]

This PR implements basic thread prioritisation on Linux and Windows and fixes a bug in dispatch_get_global_queue where the wrong QOS type is used.

Note that this only sets the initial thread priority by translating QoS to thread priorities. Relative priorities are ignored for now. Later QoS overrides and other priority adjustments have no effect.

See the comments for implementation details.

Result on Windows

#include <stdio.h>
#include <windows.h>
#include <dispatch/dispatch.h>

int main (int arg,char **argv)
{
    void (^myBlock) (void) = ^{
            PWSTR desc;
            HANDLE current = GetCurrentThread();
            int prio = GetThreadPriority(current);
            GetThreadDescription(current, &desc);
            wprintf(L"priority %d descr %ls\n", prio, desc);
            LocalFree(desc);
    };

    dispatch_queue_t backgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
    dispatch_queue_t utilityQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
    dispatch_queue_t defaultQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_queue_t highQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);

    dispatch_async(backgroundQueue, myBlock);
    dispatch_async(utilityQueue, myBlock);
    dispatch_async(defaultQueue, myBlock);
    dispatch_async(highQueue, myBlock);

    dispatch_main();

}

hugo@YellowBox MSYS /tmp
# ./a.exe
priority 0 descr com.apple.root.default-qos
priority -1 descr com.apple.root.utility-qos
priority -4 descr com.apple.root.background-qos
priority 1 descr com.apple.root.user-initiated-qos

Result on Linux

#include <stdio.h>
#include <dispatch/dispatch.h>
#include <pthread.h>
#include <sys/resource.h>

int main (int arg,char **argv)
{
    void (^myBlock) (void) = ^{
	    int prio = getpriority(PRIO_PROCESS, 0);
	    printf("block with priority %d \n", prio);
    };

    dispatch_queue_t backgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
    dispatch_queue_t utilityQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
    dispatch_queue_t defaultQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_queue_t highQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);

    dispatch_async(backgroundQueue, myBlock);
    dispatch_async(utilityQueue, myBlock);
    dispatch_async(defaultQueue, myBlock);
    dispatch_async(highQueue, myBlock);

    dispatch_main();
}

block with priority 2
block with priority 0
block with priority 10
block with priority -2

[hmelder]

We can probably move all platform-dependent thread prioritisation logic into a new function like _dispatch_set_priority() (analog to _dispatch_get_priority()). This function sets the TSD slot __TSD_THREAD_QOS_CLASS on Darwin, setpriority on Linux, and SetThreadPriority on Windows.

[triplef]

@compnerd @lxbndr would be great to get your thoughts on this. 🙏

[compnerd]

This is somewhat scary for me. This can unintentionally starve the system. Generally speaking, user input threads should be THREAD_PRIORITY_NORMAL.

[hmelder]

Oh you are right. So should we just return THREAD_PRIORITY_NORMAL for INITIATED and INTERACTIVE?

Use HIGH_PRIORITY_CLASS with care. If a thread runs at the highest priority level for extended periods, other threads in the system will not get processor time. If several threads are set at high priority at the same time, the threads lose their effectiveness. The high-priority class should be reserved for threads that must respond to time-critical events.
https://learn.microsoft.com/en-us/windows/win32/procthread/scheduling-priorities

[compnerd]

Can we inline this into a wrapper on Windows for SetThreadDescription? That would allow us to avoid the extra free.

[hmelder]

Something like _dispatch_win32_set_thread_description(HANDLE hThread, const char *threadDescription)?