Struct AutoPlan 

pub struct AutoPlan {
    pub every: u64,
    pub interval: u64,
    pub raise_interval: u64,
    pub max_step: u32,
    pub next: Vec<SizingChange>,
    pub held: Vec<SizingHold>,
    pub blocked: Option<String>,
    pub refused: Vec<SizingRefused>,
}

What auto sizing will do: its rules, the changes its next look would make as the history and config are now, and the profiles a recent change holds.

Fields

every: u64

Seconds between two looks of the daemon’s.

interval: u64

[sizing] interval: the least time between a change to one profile and one that lowers it, in seconds.

raise_interval: u64

[sizing] raise_interval: the least time between a change to one profile and one that only raises it, in seconds.

max_step: u32

[sizing] max_step: the most one change moves a profile’s memory, in percent of it.

next: Vec<SizingChange>

The changes the next look would make, in the order it would make them; at is when this was worked out. None of them is made while blocked says why.

held: Vec<SizingHold>

The profiles a change in the last interval holds from some change, the hold that ends first first.

blocked: Option<String>

Why no look changes anything until the owner acts, as when the file on disk differs from the config runnerd runs with. None when the next look may write next.

refused: Vec<SizingRefused>

The profiles whose jobs the CPU cap holds back and whose cpus the next look cannot raise, and why.

Implementations

impl AutoPlan

pub fn refusal(&self, profile: &str) -> Option<String>

The cpus raise profile’s jobs ask for and the next look cannot make, as a line of its own beside what it does next, which can still change its memory or slots: No CPU raise: 3 runs of … the cap holds them back; ….

pub fn profile_plan(&self, profile: &str, now: u64) -> ProfilePlan<'_>

What it does next with profile at now: a hold whose time has passed holds nothing, however old the plan.

impl AutoPlan

pub fn rules(&self) -> String

Its rules in words, as clients say them after runnerd: looks every 5 minutes, raises a profile at most once every 1 hour and lowers it at most once every 24 hours, moving its memory and CPUs by at most 25% at a time.

Trait Implementations

impl Clone for AutoPlan

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AutoPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AutoPlan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for AutoPlan

impl PartialEq for AutoPlan

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for AutoPlan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AutoPlan