Enum ThreadPriority 

pub enum ThreadPriority {
    Min,
    Crossplatform(ThreadPriorityValue),
    Os(ThreadPriorityOsValue),
    Deadline {
        runtime: Duration,
        deadline: Duration,
        period: Duration,
        flags: DeadlineFlags,
    },
    Max,
}

Thread priority enumeration.

Variants

Min

Holds a value representing the minimum possible priority.

Crossplatform(ThreadPriorityValue)

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.

Os(ThreadPriorityOsValue)

Holds an operating system specific value. If it is not possible to obtain the ThreadPriority::Crossplatform variant of the value, this is returned instead.

Deadline

Available on Linux or Android only.

Holds scheduling parameters for Deadline scheduling. These are, in order, the nanoseconds for runtime, deadline, and period. Please note that the kernel enforces runtime <= deadline <= period.

arrival/wakeup absolute deadline | start time | | | | v v v —–x––––xooooooooooooooooo––––x––––x— |<– Runtime —––>| |<———– Deadline ———–>| |<––––––– Period —————––>|

Fields

runtime: Duration

Set this to something larger than the average computation time or to the worst-case computation time for hard real-time tasks.

deadline: Duration

Set this to the relative deadline.

period: Duration

Set this to the period of the task.

flags: DeadlineFlags

Deadline flags.

Max

Holds a value representing the maximum possible priority. Should be used with caution, it solely depends on the target os where the program is going to be running on, how it will behave. On some systems, the whole system may become frozen if not used properly.

Implementations

impl ThreadPriority

pub fn max_value_for_policy(policy: ThreadSchedulePolicy) -> Result<i32, Error>

Returns the maximum allowed value for using with the provided policy. The returned number is in the range of allowed values.

pub fn min_value_for_policy(policy: ThreadSchedulePolicy) -> Result<i32, Error>

Returns the minimum allowed value for using with the provided policy. The returned number is in the range of allowed values.

pub fn to_allowed_value_for_policy( priority: i32, policy: ThreadSchedulePolicy, ) -> Result<i32, Error>

Checks that the passed priority value is within the range of allowed values for using with the provided policy.

pub fn to_posix(self, policy: ThreadSchedulePolicy) -> Result<i32, Error>

Converts the priority stored to a posix number. POSIX value can not be known without knowing the scheduling policy https://linux.die.net/man/2/sched_get_priority_max

For threads scheduled under one of the normal scheduling policies (SCHED_OTHER, SCHED_IDLE, SCHED_BATCH), sched_priority is not used in scheduling decisions (it must be specified as 0). Source: https://man7.org/linux/man-pages/man7/sched.7.html Due to this restriction of normal scheduling policies and the intention of the library, the niceness is used instead for such processes.

pub fn from_posix(params: ScheduleParams) -> ThreadPriority

Gets priority value from POSIX value. In order to interpret it correctly, you should also take scheduling policy into account.

impl ThreadPriority

pub fn set_for_current(self) -> Result<(), Error>

Sets current thread’s priority to this value.

Trait Implementations

impl Clone for ThreadPriority

fn clone(&self) -> ThreadPriority

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ThreadPriority

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for ThreadPriority

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for ThreadPriority

fn cmp(&self, other: &ThreadPriority) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ThreadPriority

fn eq(&self, other: &ThreadPriority) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for ThreadPriority

fn partial_cmp(&self, other: &ThreadPriority) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl TryFrom<u8> for ThreadPriority

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from( value: u8, ) -> Result<ThreadPriority, <ThreadPriority as TryFrom<u8>>::Error>

Performs the conversion.

impl Copy for ThreadPriority

impl Eq for ThreadPriority

impl StructuralPartialEq for ThreadPriority

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 56 bytes

Size for each variant:

• Min: 0 bytes
• Crossplatform: 1 byte
• Os: 4 bytes
• Deadline: 56 bytes
• Max: 0 bytes