Snapshot

Author: iddm

src/new.rs

@@ -190,25 +190,29 @@ impl From<crate::unix::Niceness> for ThreadPriority {
     fn from(value: crate::unix::Niceness) -> Self {
         use crate::unix::Niceness;
 
-        let niceness_values = Niceness::MAX.abs() + Niceness::MIN.abs();
-        let value = (((value.get_value() + Niceness::MAX) / niceness_values)
-            as ThreadPriorityValue)
+        // Add 1 to include the corner value (0 also counts), so in the
+        // range of [-20;19] there are 40 values, not just 39.
+        let niceness_values = Niceness::MAX.abs() + Niceness::MIN.abs() + 1;
+        let value = ((((value.get_value() + Niceness::MAX.abs()) as f32 / niceness_values as f32)
+            * 100.0f32) as ThreadPriorityValue)
             .clamp(ThreadPriority::MINIMUM.0, ThreadPriority::MAXIMUM.0);
         Self(value)
     }
 }
 
+/// Maps the [0;100] range to [-19;20].
 #[cfg(not(windows))]
 impl From<ThreadPriority> for crate::unix::Niceness {
     fn from(value: ThreadPriority) -> Self {
         use crate::unix::{Niceness, NicenessValue};
 
-        let niceness_values = Niceness::MAX.abs() + Niceness::MIN.abs();
+        // Add one to include the corner value.
+        let niceness_values = Niceness::MAX.abs() + Niceness::MIN.abs() + 1;
         // As the MIN-MAX is [0; 100], we don't need to work with percentages:
         // the value may already be considered a percentage.
-        let ratio = value.0 as f32;
-        let niceness =
-            ((niceness_values as f32 * ratio) as NicenessValue + Niceness::MAX) as NicenessValue;
+        let ratio = -(value.0 as f32 / ThreadPriority::MAXIMUM.0 as f32);
+        let niceness_value = (niceness_values as f32 * ratio) as NicenessValue;
+        let niceness = (niceness_value + Niceness::MAX.abs() + 1) as NicenessValue;
         Niceness::new_unchecked(niceness)
     }
 }
@@ -239,6 +243,13 @@ impl std::convert::TryFrom<UnixThreadPriority> for ThreadPriority {
 impl std::convert::TryFrom<ThreadPriority> for UnixThreadPriority {
     type Error = Error;
 
+    #[cfg_attr(
+        all(
+            any(target_os = "linux", target_os = "android"),
+            not(target_arch = "wasm32")
+        ),
+        allow(unused_variables)
+    )]
     fn try_from(value: ThreadPriority) -> Result<Self, Self::Error> {
         // We only work with the default (Other) schedule policy here.
         let policy = crate::unix::ThreadSchedulePolicy::Normal(

src/unix.rs

@@ -50,7 +50,7 @@ impl ThreadId {
             any(target_os = "linux", target_os = "android"),
             not(target_arch = "wasm32")
         ))]
-        let system = Some(get_thread_system_id());
+        let system = Some(get_thread_system_id() as libc::id_t);
         #[cfg(not(all(
             any(target_os = "linux", target_os = "android"),
             not(target_arch = "wasm32")
@@ -342,12 +342,17 @@ impl NormalThreadSchedulePolicy {
     /// Returns true if the schedule policy allows to control the thread
     /// priority only via the dynamic priority value, - niceness.
     pub fn is_niceness_based(&self) -> bool {
-        match self {
-            #[cfg(any(target_os = "linux", target_os = "android"))]
-            NormalThreadSchedulePolicy::Idle => true,
-            #[cfg(any(target_os = "linux", target_os = "android"))]
-            NormalThreadSchedulePolicy::Batch => true,
-            NormalThreadSchedulePolicy::Other => false,
+        cfg_if::cfg_if! {
+            if #[cfg(any(target_os = "linux", target_os = "android"))] {
+                // On Linux all normal thread scheduling policies can't
+                // have any other value than `0` and should be controlled
+                // via niceness.
+                return true;
+            } else {
+                // On other platforms, there is only SCHED_OTHER which
+                // can be controlled via pthread's priority.
+                return false;
+            }
         }
     }
 }
@@ -575,7 +580,9 @@ fn set_thread_priority_and_policy_deadline(
             ))
         }
     };
-    let tid = native as libc::pid_t;
+    let tid = native
+        .system
+        .ok_or(Error::Priority("Can't obtain the system thread id."))?;
     let sched_attr = SchedAttr {
         size: std::mem::size_of::<SchedAttr>() as u32,
         sched_policy: RealtimeThreadSchedulePolicy::Deadline.to_posix() as u32,
@@ -633,7 +640,7 @@ pub fn set_thread_priority_and_policy(
         // SCHED_DEADLINE policy requires its own syscall
         #[cfg(any(target_os = "linux", target_os = "android"))]
         ThreadSchedulePolicy::Realtime(RealtimeThreadSchedulePolicy::Deadline) => {
-            set_thread_priority_and_policy_deadline(thread_id.pthread, priority)
+            set_thread_priority_and_policy_deadline(thread_id, priority)
         }
         _ => {
             let fixed_priority = priority.to_posix(policy)?;
@@ -848,9 +855,9 @@ pub trait ThreadExt {
         cfg_if::cfg_if! {
             if #[cfg(all(any(target_os = "linux", target_os = "android"), not(target_arch = "wasm32")))] {
                 if policy == ThreadSchedulePolicy::Realtime(RealtimeThreadSchedulePolicy::Deadline) {
-                    set_thread_priority_and_policy(get_thread_pthread_id(), ThreadPriority::Crossplatform(ThreadPriorityValue(0)), policy)
+                    set_thread_priority_and_policy(ThreadId::get_for_current(), ThreadPriority::Crossplatform(ThreadPriorityValue(0)), policy)
                 } else {
-                    set_thread_priority_and_policy(get_thread_pthread_id(), priority, policy)
+                    set_thread_priority_and_policy(ThreadId::get_for_current(), priority, policy)
                 }
             } else {
                 set_thread_priority_and_policy(ThreadId::get_for_current(), priority, policy)
@@ -919,7 +926,7 @@ mod tests {
         use std::time::Duration;
 
         assert!(set_thread_priority_and_policy(
-            0, // current thread
+            ThreadId::get_for_current(),
             ThreadPriority::Deadline {
                 runtime: Duration::from_millis(1),
                 deadline: Duration::from_millis(10),

tests/unix.rs

@@ -16,7 +16,7 @@ fn get_and_set_priority_with_normal_policies(
     #[values(ThreadPriority::Min, ThreadPriority::Max, ThreadPriority::Crossplatform(23u8.try_into().unwrap()))]
     priority: ThreadPriority,
 ) {
-    let ret = set_thread_priority_and_policy(get_thread_pthread_id(), priority, policy);
+    let ret = set_thread_priority_and_policy(ThreadId::get_for_current(), priority, policy);
     if policy == ThreadSchedulePolicy::Normal(NormalThreadSchedulePolicy::Idle)
         && priority == ThreadPriority::Crossplatform(23u8.try_into().unwrap())
     {