[PATCH v2 0/5] MR4551: Server-side thread priorities implementation (Part 1)
This is the current proton thread priority implementation by @rbernon rebased for upstream with a few `#ifdef`s added since AFAIK Linux is the only operating system where threads have a unique PID which can be used to set niceness on. I also ran `./tools/make_requests` on https://gitlab.winehq.org/mzent/wine/-/commit/6705d3481be0409f7e971c1d2c7a36... as well and `autoconf` on https://gitlab.winehq.org/mzent/wine/-/commit/d7bafe40c411753662b2ad97148a6c... (which does blow up the line count a bit). A few tiny changes (with the ready variable for example) are in anticipation for Part 2, which also adds Mach thread priorities and recalculates thread priorities on process priority change. Since this is a rather large MR, I hope the split here is appropriate (with the second part being slightly smaller), but I think logically it makes the most sense here. -- v2: server: Check wineserver privileges on init with -20 https://gitlab.winehq.org/wine/wine/-/merge_requests/4551
From: Rémi Bernon <rbernon(a)codeweavers.com> --- server/thread.c | 44 +++++++++++++++++++++++++++++++------------- server/thread.h | 1 + 2 files changed, 32 insertions(+), 13 deletions(-) diff --git a/server/thread.c b/server/thread.c index 83ae381d5c5..5c039828912 100644 --- a/server/thread.c +++ b/server/thread.c @@ -606,25 +606,39 @@ affinity_t get_thread_affinity( struct thread *thread ) #define THREAD_PRIORITY_REALTIME_HIGHEST 6 #define THREAD_PRIORITY_REALTIME_LOWEST -7 +int set_thread_priority( struct thread *thread, int priority_class, int priority ) +{ + int max = THREAD_PRIORITY_HIGHEST; + int min = THREAD_PRIORITY_LOWEST; + if (priority_class == PROCESS_PRIOCLASS_REALTIME) + { + max = THREAD_PRIORITY_REALTIME_HIGHEST; + min = THREAD_PRIORITY_REALTIME_LOWEST; + } + if ((priority < min || priority > max) && + priority != THREAD_PRIORITY_IDLE && + priority != THREAD_PRIORITY_TIME_CRITICAL) + { + errno = EINVAL; + return -1; + } + + if (thread->process->priority == priority_class && + thread->priority == priority) + return 0; + thread->priority = priority; + + return 0; +} + /* set all information about a thread */ static void set_thread_info( struct thread *thread, const struct set_thread_info_request *req ) { if (req->mask & SET_THREAD_INFO_PRIORITY) { - int max = THREAD_PRIORITY_HIGHEST; - int min = THREAD_PRIORITY_LOWEST; - if (thread->process->priority == PROCESS_PRIOCLASS_REALTIME) - { - max = THREAD_PRIORITY_REALTIME_HIGHEST; - min = THREAD_PRIORITY_REALTIME_LOWEST; - } - if ((req->priority >= min && req->priority <= max) || - req->priority == THREAD_PRIORITY_IDLE || - req->priority == THREAD_PRIORITY_TIME_CRITICAL) - thread->priority = req->priority; - else - set_error( STATUS_INVALID_PARAMETER ); + if (set_thread_priority( thread, thread->process->priority, req->priority )) + file_set_error(); } if (req->mask & SET_THREAD_INFO_AFFINITY) { @@ -1413,7 +1427,10 @@ DECL_HANDLER(init_first_thread) if (!process->parent_id) process->affinity = current->affinity = get_thread_affinity( current ); else + { + set_thread_priority( current, current->process->priority, current->priority ); set_thread_affinity( current, current->affinity ); + } debug_level = max( debug_level, req->debug_level ); @@ -1444,6 +1461,7 @@ DECL_HANDLER(init_thread) init_thread_context( current ); generate_debug_event( current, DbgCreateThreadStateChange, &req->entry ); + set_thread_priority( current, current->process->priority, current->priority ); set_thread_affinity( current, current->affinity ); reply->suspend = (current->suspend || current->process->suspend || current->context != NULL); diff --git a/server/thread.h b/server/thread.h index 8dcf966a90a..b0237c3a80e 100644 --- a/server/thread.h +++ b/server/thread.h @@ -119,6 +119,7 @@ extern void thread_cancel_apc( struct thread *thread, struct object *owner, enum extern int thread_add_inflight_fd( struct thread *thread, int client, int server ); extern int thread_get_inflight_fd( struct thread *thread, int client ); extern struct token *thread_get_impersonation_token( struct thread *thread ); +extern int set_thread_priority( struct thread *thread, int priority_class, int priority ); extern int set_thread_affinity( struct thread *thread, affinity_t affinity ); extern int suspend_thread( struct thread *thread ); extern int resume_thread( struct thread *thread ); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/4551
From: Rémi Bernon <rbernon(a)codeweavers.com> --- server/thread.c | 26 ++++++++++++++++++++++++++ server/thread.h | 1 + 2 files changed, 27 insertions(+) diff --git a/server/thread.c b/server/thread.c index 5c039828912..5f07663bf23 100644 --- a/server/thread.c +++ b/server/thread.c @@ -240,6 +240,7 @@ static inline void init_thread_structure( struct thread *thread ) thread->state = RUNNING; thread->exit_code = 0; thread->priority = 0; + thread->delay_priority = NULL; thread->suspend = 0; thread->dbg_hidden = 0; thread->desktop_users = 0; @@ -402,6 +403,9 @@ static void cleanup_thread( struct thread *thread ) { int i; + if (thread->delay_priority) remove_timeout_user( thread->delay_priority ); + thread->delay_priority = NULL; + if (thread->context) { thread->context->status = STATUS_ACCESS_DENIED; @@ -606,6 +610,27 @@ affinity_t get_thread_affinity( struct thread *thread ) #define THREAD_PRIORITY_REALTIME_HIGHEST 6 #define THREAD_PRIORITY_REALTIME_LOWEST -7 +static void apply_thread_priority( struct thread *thread, int priority_class, int priority, int delayed ); + +static void delayed_set_thread_priority( void *private ) +{ + struct thread *thread = private; + int priority_class = thread->process->priority, priority = thread->priority; + apply_thread_priority( thread, priority_class, priority, TRUE ); +} + +static void apply_thread_priority( struct thread *thread, int priority_class, int priority, int delayed ) +{ + if (!delayed && thread->delay_priority) remove_timeout_user( thread->delay_priority ); + thread->delay_priority = NULL; + + if (thread->unix_tid == -1) + { + thread->delay_priority = add_timeout_user( -TICKS_PER_SEC, delayed_set_thread_priority, thread ); + return; + } +} + int set_thread_priority( struct thread *thread, int priority_class, int priority ) { int max = THREAD_PRIORITY_HIGHEST; @@ -628,6 +653,7 @@ int set_thread_priority( struct thread *thread, int priority_class, int priority return 0; thread->priority = priority; + apply_thread_priority( thread, priority_class, priority, FALSE ); return 0; } diff --git a/server/thread.h b/server/thread.h index b0237c3a80e..ca601aa9bb9 100644 --- a/server/thread.h +++ b/server/thread.h @@ -80,6 +80,7 @@ struct thread client_ptr_t entry_point; /* entry point (in client address space) */ affinity_t affinity; /* affinity mask */ int priority; /* priority level */ + struct timeout_user *delay_priority;/* delayed set_thread_priority */ int suspend; /* suspend count */ int dbg_hidden; /* hidden from debugger */ obj_handle_t desktop; /* desktop handle */ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/4551
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/ntdll/unix/loader.c | 3 +++ dlls/ntdll/unix/server.c | 14 ++++++++++++++ include/wine/server_protocol.h | 4 +++- server/process.h | 1 + server/protocol.def | 1 + server/request.h | 3 ++- server/thread.c | 7 +++++++ server/trace.c | 1 + 8 files changed, 32 insertions(+), 2 deletions(-) diff --git a/dlls/ntdll/unix/loader.c b/dlls/ntdll/unix/loader.c index aa120ae38ec..9dd6c672336 100644 --- a/dlls/ntdll/unix/loader.c +++ b/dlls/ntdll/unix/loader.c @@ -2125,6 +2125,9 @@ DECLSPEC_EXPORT void __wine_main( int argc, char *argv[], char *envp[] ) #ifdef RLIMIT_AS set_max_limit( RLIMIT_AS ); #endif +#ifdef RLIMIT_NICE + set_max_limit( RLIMIT_NICE ); +#endif virtual_init(); init_environment( argc, argv, envp ); diff --git a/dlls/ntdll/unix/server.c b/dlls/ntdll/unix/server.c index 7211457387c..bfb14173d60 100644 --- a/dlls/ntdll/unix/server.c +++ b/dlls/ntdll/unix/server.c @@ -53,6 +53,9 @@ # include <sys/prctl.h> #endif #include <sys/stat.h> +#ifdef HAVE_SYS_RESOURCE_H +# include <sys/resource.h> +#endif #ifdef HAVE_SYS_SYSCALL_H # include <sys/syscall.h> #endif @@ -1552,6 +1555,8 @@ size_t server_init_process(void) struct sigaction sig_act; size_t info_size; DWORD pid, tid; + struct rlimit rlimit; + int nice_limit = 0; server_pid = -1; if (env_socket) @@ -1613,10 +1618,19 @@ size_t server_init_process(void) reply_pipe = init_thread_pipe(); +#ifdef RLIMIT_NICE + if (!getrlimit( RLIMIT_NICE, &rlimit )) + { + if (rlimit.rlim_cur <= 40) nice_limit = 20 - rlimit.rlim_cur; + else if (rlimit.rlim_cur == -1 /* RLIMIT_INFINITY */) nice_limit = -20; + } +#endif + SERVER_START_REQ( init_first_thread ) { req->unix_pid = getpid(); req->unix_tid = get_unix_tid(); + req->nice_limit = nice_limit; req->reply_fd = reply_pipe; req->wait_fd = ntdll_get_thread_data()->wait_fd[1]; req->debug_level = (TRACE_ON(server) != 0); diff --git a/include/wine/server_protocol.h b/include/wine/server_protocol.h index a392b532f4e..f2fb0474803 100644 --- a/include/wine/server_protocol.h +++ b/include/wine/server_protocol.h @@ -988,6 +988,8 @@ struct init_first_thread_request int debug_level; int reply_fd; int wait_fd; + char nice_limit; + char __pad_33[7]; }; struct init_first_thread_reply { @@ -6504,7 +6506,7 @@ union generic_reply /* ### protocol_version begin ### */ -#define SERVER_PROTOCOL_VERSION 784 +#define SERVER_PROTOCOL_VERSION 785 /* ### protocol_version end ### */ diff --git a/server/process.h b/server/process.h index 97e0d455ece..203a97d6682 100644 --- a/server/process.h +++ b/server/process.h @@ -50,6 +50,7 @@ struct process timeout_t sigkill_delay; /* delay before final SIGKILL */ unsigned short machine; /* client machine type */ int unix_pid; /* Unix pid for final SIGKILL */ + int nice_limit; /* RLIMIT_NICE of the process */ int exit_code; /* process exit code */ int running_threads; /* number of threads running in this process */ timeout_t start_time; /* absolute time at process start */ diff --git a/server/protocol.def b/server/protocol.def index e9195df6b65..fb4aa32ad18 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -969,6 +969,7 @@ typedef struct int debug_level; /* new debug level */ int reply_fd; /* fd for reply pipe */ int wait_fd; /* fd for blocking calls pipe */ + char nice_limit; /* RLIMIT_NICE of new thread */ @REPLY process_id_t pid; /* process id of the new thread's process */ thread_id_t tid; /* thread id of the new thread */ diff --git a/server/request.h b/server/request.h index d6043c5fdc3..c2dc4a8ada4 100644 --- a/server/request.h +++ b/server/request.h @@ -786,7 +786,8 @@ C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, unix_tid) == 16 ); C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, debug_level) == 20 ); C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, reply_fd) == 24 ); C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, wait_fd) == 28 ); -C_ASSERT( sizeof(struct init_first_thread_request) == 32 ); +C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, nice_limit) == 32 ); +C_ASSERT( sizeof(struct init_first_thread_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, pid) == 8 ); C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, tid) == 12 ); C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, server_start) == 16 ); diff --git a/server/thread.c b/server/thread.c index 5f07663bf23..854867689c9 100644 --- a/server/thread.c +++ b/server/thread.c @@ -37,6 +37,12 @@ #define _WITH_CPU_SET_T #include <sched.h> #endif +#ifdef HAVE_SYS_TIME_H +#include <sys/time.h> +#endif +#ifdef HAVE_SYS_RESOURCE_H +#include <sys/resource.h> +#endif #include "ntstatus.h" #define WIN32_NO_STATUS @@ -1449,6 +1455,7 @@ DECL_HANDLER(init_first_thread) current->unix_pid = process->unix_pid = req->unix_pid; current->unix_tid = req->unix_tid; + process->nice_limit = req->nice_limit; if (!process->parent_id) process->affinity = current->affinity = get_thread_affinity( current ); diff --git a/server/trace.c b/server/trace.c index 55ccefa1746..5a099071752 100644 --- a/server/trace.c +++ b/server/trace.c @@ -1472,6 +1472,7 @@ static void dump_init_first_thread_request( const struct init_first_thread_reque fprintf( stderr, ", debug_level=%d", req->debug_level ); fprintf( stderr, ", reply_fd=%d", req->reply_fd ); fprintf( stderr, ", wait_fd=%d", req->wait_fd ); + fprintf( stderr, ", nice_limit=%c", req->nice_limit ); } static void dump_init_first_thread_reply( const struct init_first_thread_reply *req ) -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/4551
From: Rémi Bernon <rbernon(a)codeweavers.com> --- configure | 37 +++++++++++++++++++++++++++++ configure.ac | 10 ++++++++ server/main.c | 1 + server/object.h | 4 ++++ server/thread.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 113 insertions(+), 1 deletion(-) diff --git a/configure b/configure index 3b8ec628bfb..ab7aa588f89 100755 --- a/configure +++ b/configure @@ -20435,6 +20435,43 @@ printf "%s\n" "#define HAVE_SCHED_SETAFFINITY 1" >>confdefs.h fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for setpriority" >&5 +printf %s "checking for setpriority... " >&6; } +if test ${wine_cv_have_setpriority+y} +then : + printf %s "(cached) " >&6 +else $as_nop + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#define _GNU_SOURCE +#include <sys/resource.h> +#include <sys/time.h> +int +main (void) +{ +setpriority(0, 0, 0); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO" +then : + wine_cv_have_setpriority=yes +else $as_nop + wine_cv_have_setpriority=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam \ + conftest$ac_exeext conftest.$ac_ext +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $wine_cv_have_setpriority" >&5 +printf "%s\n" "$wine_cv_have_setpriority" >&6; } +if test "$wine_cv_have_setpriority" = "yes" +then + +printf "%s\n" "#define HAVE_SETPRIORITY 1" >>confdefs.h + +fi + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for inline" >&5 printf %s "checking for inline... " >&6; } diff --git a/configure.ac b/configure.ac index 074086c586b..b50f1d162aa 100644 --- a/configure.ac +++ b/configure.ac @@ -2090,6 +2090,16 @@ then AC_DEFINE(HAVE_SCHED_SETAFFINITY, 1, [Define to 1 if you have the `sched_setaffinity' function.]) fi +AC_CACHE_CHECK([for setpriority],wine_cv_have_setpriority, + AC_LINK_IFELSE([AC_LANG_PROGRAM( +[[#define _GNU_SOURCE +#include <sys/resource.h> +#include <sys/time.h>]], [[setpriority(0, 0, 0);]])],[wine_cv_have_setpriority=yes],[wine_cv_have_setpriority=no])) +if test "$wine_cv_have_setpriority" = "yes" +then + AC_DEFINE(HAVE_SETPRIORITY, 1, [Define to 1 if you have the `setpriority' function.]) +fi + dnl **** Check for types **** AC_C_INLINE diff --git a/server/main.c b/server/main.c index 1248b92f24d..e014ec535ff 100644 --- a/server/main.c +++ b/server/main.c @@ -234,6 +234,7 @@ int main( int argc, char *argv[] ) init_signals(); init_memory(); init_directories( load_intl_file() ); + init_threading(); init_registry(); main_loop(); return 0; diff --git a/server/object.h b/server/object.h index dfdd691601f..66012fbc4af 100644 --- a/server/object.h +++ b/server/object.h @@ -277,6 +277,10 @@ extern struct object *get_directory_obj( struct process *process, obj_handle_t h extern int directory_link_name( struct object *obj, struct object_name *name, struct object *parent ); extern void init_directories( struct fd *intl_fd ); +/* thread functions */ + +extern void init_threading(void); + /* symbolic link functions */ extern struct object *create_root_symlink( struct object *root, const struct unicode_str *name, diff --git a/server/thread.c b/server/thread.c index 854867689c9..eef846af7bc 100644 --- a/server/thread.c +++ b/server/thread.c @@ -221,6 +221,27 @@ static const struct fd_ops thread_fd_ops = }; static struct list thread_list = LIST_INIT(thread_list); +#ifdef __linux__ +static int nice_limit; +#endif + +void init_threading(void) +{ +#ifdef __linux__ +#ifdef RLIMIT_NICE + struct rlimit rlimit; + if (!getrlimit( RLIMIT_NICE, &rlimit )) + { + rlimit.rlim_cur = rlimit.rlim_max; + setrlimit( RLIMIT_NICE, &rlimit ); + if (rlimit.rlim_max <= 40) nice_limit = 20 - rlimit.rlim_max; + else if (rlimit.rlim_max == -1) nice_limit = -20; + if (nice_limit >= 0) fprintf(stderr, "wine: RLIMIT_NICE is <= 20, unable to use setpriority safely\n"); + } +#endif + if (nice_limit < 0) fprintf(stderr, "wine: Using setpriority to control niceness in the [%d,%d] range\n", nice_limit, -nice_limit ); +#endif +} /* initialize the structure for a newly allocated thread */ static inline void init_thread_structure( struct thread *thread ) @@ -613,6 +634,23 @@ affinity_t get_thread_affinity( struct thread *thread ) return mask; } +static int get_base_priority( int priority_class, int priority ) +{ + static const int class_offsets[] = { 4, 8, 13, 24, 6, 10 }; + assert(priority_class <= ARRAY_SIZE(class_offsets)); + if (priority == THREAD_PRIORITY_IDLE) return (priority_class == PROCESS_PRIOCLASS_REALTIME ? 16 : 1); + else if (priority == THREAD_PRIORITY_TIME_CRITICAL) return (priority_class == PROCESS_PRIOCLASS_REALTIME ? 31 : 15); + else return class_offsets[priority_class - 1] + priority; +} + +#ifdef __linux__ +static int get_unix_niceness( int base_priority, int limit ) +{ + int min = -limit, max = limit, range = max - min; + return min + (base_priority - 1) * range / 14; +} +#endif + #define THREAD_PRIORITY_REALTIME_HIGHEST 6 #define THREAD_PRIORITY_REALTIME_LOWEST -7 @@ -627,14 +665,36 @@ static void delayed_set_thread_priority( void *private ) static void apply_thread_priority( struct thread *thread, int priority_class, int priority, int delayed ) { + int base_priority = get_base_priority( priority_class, priority ); +#ifdef __linux__ + int niceness, limit = min( nice_limit, thread->process->nice_limit ); + int ready = thread->unix_tid != -1; +#else + int ready = TRUE; +#endif + if (!delayed && thread->delay_priority) remove_timeout_user( thread->delay_priority ); thread->delay_priority = NULL; - if (thread->unix_tid == -1) + if (!ready) { thread->delay_priority = add_timeout_user( -TICKS_PER_SEC, delayed_set_thread_priority, thread ); return; } + +#ifdef __linux__ + /* FIXME: handle REALTIME class using SCHED_RR if possible, for now map it to highest non-realtime band */ + if (priority_class == PROCESS_PRIOCLASS_REALTIME) base_priority = 15; +#ifdef HAVE_SETPRIORITY + if (limit < 0) + { + niceness = get_unix_niceness( base_priority, limit ); + if (setpriority( PRIO_PROCESS, thread->unix_tid, niceness ) != 0) + fprintf( stderr, "wine: setpriority %d for pid %d failed: %d\n", niceness, thread->unix_tid, errno ); + return; + } +#endif +#endif } int set_thread_priority( struct thread *thread, int priority_class, int priority ) -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/4551
From: Rémi Bernon <rbernon(a)codeweavers.com> --- server/thread.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/server/thread.c b/server/thread.c index eef846af7bc..190520167f7 100644 --- a/server/thread.c +++ b/server/thread.c @@ -230,7 +230,13 @@ void init_threading(void) #ifdef __linux__ #ifdef RLIMIT_NICE struct rlimit rlimit; - if (!getrlimit( RLIMIT_NICE, &rlimit )) +#endif +#ifdef HAVE_SETPRIORITY + if (setpriority( PRIO_PROCESS, getpid(), -20 ) == 0) nice_limit = -19; + setpriority( PRIO_PROCESS, getpid(), 0 ); +#endif +#ifdef RLIMIT_NICE + if (!nice_limit && !getrlimit( RLIMIT_NICE, &rlimit )) { rlimit.rlim_cur = rlimit.rlim_max; setrlimit( RLIMIT_NICE, &rlimit ); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/4551
Rémi Bernon (@rbernon) commented about server/thread.c:
+ +void init_threading(void) +{ +#ifdef __linux__ +#ifdef RLIMIT_NICE + struct rlimit rlimit; + if (!getrlimit( RLIMIT_NICE, &rlimit )) + { + rlimit.rlim_cur = rlimit.rlim_max; + setrlimit( RLIMIT_NICE, &rlimit ); + if (rlimit.rlim_max <= 40) nice_limit = 20 - rlimit.rlim_max; + else if (rlimit.rlim_max == -1) nice_limit = -20; + if (nice_limit >= 0) fprintf(stderr, "wine: RLIMIT_NICE is <= 20, unable to use setpriority safely\n"); + } +#endif + if (nice_limit < 0) fprintf(stderr, "wine: Using setpriority to control niceness in the [%d,%d] range\n", nice_limit, -nice_limit ); We'll probably want to drop these messages.
-- https://gitlab.winehq.org/wine/wine/-/merge_requests/4551#note_54376
Rémi Bernon (@rbernon) commented about server/thread.c:
+{ + struct thread *thread = private; + int priority_class = thread->process->priority, priority = thread->priority; + apply_thread_priority( thread, priority_class, priority, TRUE ); +} + +static void apply_thread_priority( struct thread *thread, int priority_class, int priority, int delayed ) +{ + if (!delayed && thread->delay_priority) remove_timeout_user( thread->delay_priority ); + thread->delay_priority = NULL; + + if (thread->unix_tid == -1) + { + thread->delay_priority = add_timeout_user( -TICKS_PER_SEC, delayed_set_thread_priority, thread ); + return; + } I'm not completely sure why I used a timer here, it's perhaps only historical from a time where we tried to use rtkit (which can't work). It'd probably be better to re-apply the current priority when unix_tid is set.
-- https://gitlab.winehq.org/wine/wine/-/merge_requests/4551#note_54377
Fwiw you don't have to run `make_requests` or `autoconf`, it will automatically be done by the CI and by @julliard when committing (in order to ensure configure is generated consistently). -- https://gitlab.winehq.org/wine/wine/-/merge_requests/4551#note_54378
Isn't renicing disallowed by default on Linux? -- https://gitlab.winehq.org/wine/wine/-/merge_requests/4551#note_54432
It is a system wide configuration, yes, and what is disallowed by default is *reducing* niceness (ie: increasing priority, and that, to *any* level). It is IMO a stupid restriction, especially since it prevents a thread from getting back to its default niceness once it has increased it (which is always allowed). This is the reason for the `rlimit` check that is included here, used to determine the usable operating niceness range, so that we don't get stuck in a nice level we can't get out of. We also explicitly request the hard limit, so that the system can be configured with the existing default as a soft limit, as some sort of safety net against broken software. I think we should have support for it nonetheless, because it's the only reliable way to implement thread priorities (rtkit is a dead-end), and they have been reported to make a difference, greatly reducing stuttering when shaders are being compiled for instance. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/4551#note_54435
On Thu Nov 30 21:56:55 2023 +0000, Rémi Bernon wrote:
Fwiw you don't have to run `make_requests` or `autoconf`, it will automatically be done by the CI and by @julliard when committing (in order to ensure configure is generated consistently). Ah good to know! I guess since they are re-run anyways it is fine to leave them in as is?
-- https://gitlab.winehq.org/wine/wine/-/merge_requests/4551#note_54463
On Thu Nov 30 09:54:57 2023 +0000, Rémi Bernon wrote:
I'm not completely sure why I used a timer here, it's perhaps only historical from a time where we tried to use rtkit (which can't work). It'd probably be better to re-apply the current priority when unix_tid is set. If I am not mistaken unix_tid should always be set currently on both the init_first_thread and init_thread requests (and set_thread_info can only be used with an already fully initialized thread). Later on the mach port right to the target process is also needed, but the tracing mechanism is already initialized at that point in time. I guess https://gitlab.winehq.org/wine/wine/-/merge_requests/4551/diffs?commit_id=02... can be just dropped then, unless I am overlooking something here.
-- https://gitlab.winehq.org/wine/wine/-/merge_requests/4551#note_54473
Also adding to that it really does help with stuttering, but even more critical (and the main reason I looked into that) is that for a lot of games (especially Creation Engine), the audio thread is set to something like THREAD_PRIORITY_TIME_CRITICAL and the Mach scheduler quite often does not give enough of a time quantum to it resulting in audio crackles or static noise, without the extra info to prioritize it. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/4551#note_54476
participants (3)
-
Marc-Aurel Zent (＠mzent) -
Rémi Bernon
-
Zebediah Figura (＠zfigura)