WIP

Author: iddm

Cargo.toml

@@ -23,4 +23,4 @@ libc = ">=0.2.123"
 
 [target.'cfg(windows)'.dependencies]
 libc = ">=0.2.123"
-winapi = { version = "0.3", features = ["errhandlingapi", "processthreadsapi", "winnt", "minwindef", "winbase"] }
+winapi = { version = ">=0.3", features = ["errhandlingapi", "processthreadsapi", "winnt", "minwindef", "winbase"] }

src/lib.rs

@@ -172,6 +172,8 @@ impl ThreadPriorityValue {
     pub const MAX: u8 = 100;
     /// The minimum value for a thread priority.
     pub const MIN: u8 = 0;
+    /// The range of allowed values.
+    pub const RANGE: std::ops::RangeInclusive<u8> = Self::MIN..=Self::MAX;
 }
 
 impl std::convert::TryFrom<u8> for ThreadPriorityValue {
@@ -213,8 +215,26 @@ to set it to [`WinAPIThreadPriority::Idle`] when it is really needed.
     )]
     Min,
     /// Holds a platform-independent priority value.
-    /// Usually used when setting a value, for sometimes it is not possible to map
-    /// the operating system's priority to this value.
+    #[cfg_attr(
+        not(target_os = "windows"),
+        doc = "\
+        The value is used in two ways when the underlying OS is POSIX-compatible.
+# When setting the priority value
+
+- When a scheduling policy other than real-time is used, the value is mapped to the range
+of niceness values, typically ranging from -20 to 19 inclusively, so that the [`ThreadPriority::Min`] would mean the
+minimum possible value of niceness (19), the [`ThreadPriority::Max`] the maximum value (-20) and the
+[`ThreadPriority::Crossplatform`] variant would be mapped from its range of values (from [`ThreadPriorityValue::MIN`]
+to [`ThreadPriorityValue::MAX`]) to the range of [`crate::unix::NICENESS_MIN`] till [`crate::unix::NICENESS_MAX`]).
+- When a scheduling policy is the one of the real-time ones, the value is then converted to the range of possible values
+for a real-time thread of the specified real-time scheduling policy, being an argument [`libc::sched_param::sched_priority`].
+
+# When obtaining the priority value
+
+- When the scheduling policy is not real-time, the niceness-converted value is returned after mapping to the range of possible values for the [`ThreadPriorityValue`] type ([`ThreadPriorityValue::RANGE`]).
+- When the scheduling policy is real-time, the [`libc::sched_param::sched_priority`] value is converted to the range of possible values for the [`ThreadPriorityValue`] type ([`ThreadPriorityValue::RANGE`]).
+"
+    )]
     Crossplatform(ThreadPriorityValue),
     /// Holds an operating system specific value. If it is not possible to obtain the
     /// [`ThreadPriority::Crossplatform`] variant of the value, this is returned instead.

src/unix.rs

@@ -26,14 +26,11 @@ use std::mem::MaybeUninit;
 // <https://man7.org/linux/man-pages/man7/sched.7.html>
 
 /// An alias type for a thread id.
-pub type ThreadId = libc::pthread_t;
-
-/// The maximum value possible for niceness. Threads with this value
-/// of niceness have the highest priority possible
-pub const NICENESS_MAX: i8 = -20;
-/// The minimum value possible for niceness. Threads with this value
-/// of niceness have the lowest priority possible.
-pub const NICENESS_MIN: i8 = 19;
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+pub struct ThreadId {
+    pub(crate) pthread_id: libc::pthread_t,
+    pub(crate) pid: libc::pid_t,
+}
 
 /// Proxy structure to maintain compatibility between glibc and musl
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
@@ -260,7 +257,7 @@ impl ThreadPriority {
             }
             ThreadSchedulePolicy::Normal(_) => {
                 // Niceness can be used, from -20 to 19, where `-20` is the maximum.
-                Ok(NICENESS_MAX as libc::c_int)
+                Ok(Niceness::MAX as libc::c_int)
             }
             _ => {
                 let max_priority = unsafe { libc::sched_get_priority_max(policy.to_posix()) };
@@ -281,7 +278,7 @@ impl ThreadPriority {
             ThreadSchedulePolicy::Normal(NormalThreadSchedulePolicy::Idle) => Ok(0),
             ThreadSchedulePolicy::Normal(_) => {
                 // Niceness can be used, from -20 to 19, where `-20` is the maximum.
-                Ok(NICENESS_MIN as libc::c_int)
+                Ok(Niceness::MIN as libc::c_int)
             }
             _ => {
                 let min_priority = unsafe { libc::sched_get_priority_min(policy.to_posix()) };
@@ -347,9 +344,9 @@ impl ThreadPriority {
                     Self::to_allowed_value_for_policy(p as i32, policy).map(|v| v as u32)
                 }
                 ThreadSchedulePolicy::Normal(_) => {
-                    let niceness_values = NICENESS_MAX.abs() + NICENESS_MIN.abs();
+                    let niceness_values = Niceness::MAX.abs() + Niceness::MIN.abs();
                     let ratio = p as f32 / ThreadPriorityValue::MAX as f32;
-                    let niceness = ((niceness_values as f32 * ratio) as i8 + NICENESS_MAX) as i32;
+                    let niceness = ((niceness_values as f32 * ratio) as i8 + Niceness::MAX) as i32;
                     Self::to_allowed_value_for_policy(niceness, policy).map(|v| v as u32)
                 }
             },
@@ -427,7 +424,7 @@ fn set_thread_priority_and_policy_deadline(
             ))
         }
     };
-    let tid = native as libc::pid_t;
+    let tid = native.pthread_id as libc::pid_t;
     let sched_attr = SchedAttr {
         size: std::mem::size_of::<SchedAttr>() as u32,
         sched_policy: RealtimeThreadSchedulePolicy::Deadline.to_posix() as u32,
@@ -497,9 +494,11 @@ pub fn set_thread_priority_and_policy(
                 }
                 .into_posix();
 
+                set_errno(0);
+
                 let ret = unsafe {
                     libc::pthread_setschedparam(
-                        native,
+                        native.pthread_id,
                         policy.to_posix(),
                         &params as *const libc::sched_param,
                     )
@@ -577,7 +576,7 @@ pub fn thread_schedule_policy_param(
         let mut params = ScheduleParams { sched_priority: 0 }.into_posix();
 
         let ret = libc::pthread_getschedparam(
-            native,
+            native.pthread_id,
             &mut policy as *mut libc::c_int,
             &mut params as *mut libc::sched_param,
         );
@@ -591,11 +590,116 @@ pub fn thread_schedule_policy_param(
     }
 }
 
+#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+struct Niceness(pub libc::c_int);
+impl Niceness {
+    /// The maximum value possible for niceness. Threads with this value
+    /// of niceness have the highest priority possible
+    pub const MAX: i8 = -20;
+    /// The minimum value possible for niceness. Threads with this value
+    /// of niceness have the lowest priority possible.
+    pub const MIN: i8 = 19;
+    /// The range of possible values.
+    pub const RANGE: std::ops::RangeInclusive<i8> = Self::MAX..=Self::MIN;
+    // TODO this is commented out since the std::cmp::{min,max} do not have const fn analogs.
+    // pub const RANGE: std::ops::RangeInclusive<i8> =
+    //     std::cmp::min(Self::MIN, Self::MAX)..=std::cmp::max(Self::MIN, Self::MAX);
+}
+
+impl TryFrom<i8> for Niceness {
+    type Error = Error;
+
+    fn try_from(value: i8) -> Result<Self, Self::Error> {
+        if Self::RANGE.contains(&value) {
+            return Ok(Self(value as libc::c_int));
+        }
+        Err(Error::PriorityNotInRange(
+            Self::MIN as i32..=Self::MAX as i32,
+        ))
+    }
+}
+
+impl TryFrom<Niceness> for ThreadPriority {
+    type Error = Error;
+
+    fn try_from(value: Niceness) -> Result<Self, Self::Error> {
+        Ok(ThreadPriority::Crossplatform(
+            ThreadPriorityValue::try_from(value)?,
+        ))
+    }
+}
+
+impl TryFrom<ThreadPriorityValue> for Niceness {
+    type Error = Error;
+
+    fn try_from(value: ThreadPriorityValue) -> Result<Self, Self::Error> {
+        // we need -20;19 from 0-100.
+
+        let niceness_values = Niceness::MAX.abs() + Niceness::MIN.abs();
+        let niceness = (value.0 as f32) / 100.0f32 * (niceness_values as f32);
+        let niceness = niceness as libc::c_int - (Niceness::MAX.abs() as i32);
+
+        Ok(Niceness(niceness))
+    }
+}
+
+impl TryFrom<Niceness> for ThreadPriorityValue {
+    type Error = Error;
+
+    fn try_from(value: Niceness) -> Result<Self, Self::Error> {
+        // we need 0-100 from 0-40.
+        let value = value.0 + (Niceness::MAX.abs() as i32);
+        let niceness_values = Niceness::MAX.abs() + Niceness::MIN.abs();
+        let priority = ((niceness_values as f32) / 100.0f32 * (value as f32)) as libc::c_int;
+
+        if let Ok(priority) = u8::try_from(priority) {
+            ThreadPriorityValue::try_from(priority).map_err(Error::Priority)
+        } else {
+            Err(Error::PriorityNotInRange(
+                Niceness::MAX as i32..=Niceness::MIN as i32,
+            ))
+        }
+    }
+}
+
+/// Returns the thread's niceness.
+///
+/// # Example
+/// ```rust
+/// use thread_priority::*;
+/// use std::convert::TryInto;
+///
+/// let thread_id = std::thread::current().get_native_id();
+/// let niceness = thread_niceness(thread_id);
+/// assert_eq!(niceness, Ok(ThreadPriority::Crossplatform(0u8.try_into().unwrap())));
+/// ```
+pub fn thread_niceness(native: ThreadId) -> Result<ThreadPriority, Error> {
+    set_errno(0);
+
+    dbg!(native);
+    let thread_pid = u32::try_from(native.pid)
+        .map_err(|_| Error::Ffi("Couldn't convert the native thread id."))?;
+    unsafe {
+        let niceness = match libc::getpriority(libc::PRIO_PROCESS, thread_pid) {
+            -1 => match errno() {
+                0 => Niceness::try_from(-1)?,
+                e => return Err(Error::OS(e)),
+            },
+            niceness => Niceness(niceness),
+        };
+        let priority = ThreadPriorityValue::try_from(niceness)?;
+        Ok(ThreadPriority::Crossplatform(priority))
+    }
+}
+
 /// Get the thread's priority value.
 pub fn get_thread_priority(native: ThreadId) -> Result<ThreadPriority, Error> {
-    Ok(ThreadPriority::from_posix(
-        thread_schedule_policy_param(native)?.1,
-    ))
+    let posix = thread_schedule_policy_param(native)?;
+
+    match posix.0 {
+        ThreadSchedulePolicy::Normal(_) => thread_niceness(native),
+        _ => Ok(ThreadPriority::from_posix(posix.1)),
+    }
 }
 
 /// Get current thread's priority value.
@@ -697,19 +801,25 @@ impl ThreadExt for std::thread::Thread {}
 /// ```rust
 /// use thread_priority::thread_native_id;
 ///
-/// assert!(thread_native_id() > 0);
+/// let _thread_id = thread_native_id();
 /// ```
 pub fn thread_native_id() -> ThreadId {
-    unsafe { libc::pthread_self() }
+    let pthread_id = unsafe { libc::pthread_self() };
+    #[cfg(linux)]
+    let pid = unsafe { libc::gettid() };
+    #[cfg(not(linux))]
+    let pid = unsafe { libc::getpid() };
+    ThreadId { pthread_id, pid }
 }
 
 impl TryFrom<u8> for ThreadPriority {
     type Error = &'static str;
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
-        if let 0..=100 = value {
+        if ThreadPriorityValue::RANGE.contains(&value) {
             Ok(ThreadPriority::Crossplatform(ThreadPriorityValue(value)))
         } else {
+            // TODO create a string with the range of values as constexpr.
             Err("The thread priority value must be in range of [0; 100].")
         }
     }
@@ -734,7 +844,10 @@ mod tests {
         use std::time::Duration;
 
         assert!(set_thread_priority_and_policy(
-            0, // current thread
+            ThreadId {
+                pthread_id: 0,
+                pid: 0,
+            },
             ThreadPriority::Deadline {
                 runtime: Duration::from_millis(1),
                 deadline: Duration::from_millis(10),