Struct Params 

pub struct Params<'a> {
    pub(crate) open: &'a mut OpenObject,
    pub(crate) set: BTreeSet<String>,
    pub(crate) flags: u64,
}

The tunables of an object that is open and not loaded yet, the ones it declares with scx_rustsched::params!, to set before the load, and the ops flags it is loaded with. It records which tunables were set: run() refuses to start a scheduler that has one nobody set.

Fields

open: &'a mut OpenObject

set: BTreeSet<String>

flags: u64

Implementations

impl<'a> Params<'a>

pub fn new(open: &'a mut OpenObject, flags: u64) -> Self

The tunables of open, which is loaded with the ops flags.

pub fn flags(&self) -> u64

The ops flags the scheduler is loaded with: the ones #[scheduler] declares until changed here.

pub fn add_flags(&mut self, flags: u64)

Load the scheduler with the ops flags too, such as one the running kernel may lack, which compat reads as 0 there.

pub fn clear_flags(&mut self, flags: u64)

Load the scheduler without the ops flags.

pub fn type_of(&mut self, name: &str) -> Option<String>

The type of the tunable name, if the scheduler has it.

pub(crate) fn write( &mut self, name: &str, bytes: impl FnOnce(&str, usize) -> Result<Vec<u8>>, ) -> Result<()>

Give the tunable name, of type ty, the first data.len() bytes bytes(data.len()) returns.

pub fn set_text(&mut self, name: &str, text: &str) -> Result<()>

Set a tunable from the value of a command line option: true or false for a bool, and otherwise an integer, decimal or 0x hexadecimal, in the range of the tunable’s type.

pub fn set<T: ParamValue>(&mut self, name: &str, values: &[T]) -> Result<()>

Set a tunable from values of its own type: one for an integer or a bool, and for an array at most as many as it has elements, the rest of which become zero.

pub fn set_options<A: Args>(&mut self, matches: &ArgMatches) -> Result<()>

Set the tunables the options A name, from the command line as parsed: an option sets the tunable of its name, so steal, given as --steal, sets STEAL. A time in microseconds or milliseconds sets the tunable in nanoseconds: slice_us, given as --slice-us, sets SLICE_NS to a thousand times its value. An option’s default is the one in A, which the scheduler starts with whatever default the tunable was declared with. An option that names no tunable, or an array, is left to the scheduler’s own settings.

pub fn check(self) -> Result<()>

Fail if the scheduler has a tunable that was not set: an option whose name does not match the tunable it is meant for, or one left out of the loader’s own settings.