Struct MemoryResources 

pub struct MemoryResources {
    pub kernel_memory_limit: Option<i64>,
    pub memory_hard_limit: Option<i64>,
    pub memory_soft_limit: Option<i64>,
    pub kernel_tcp_memory_limit: Option<i64>,
    pub memory_swap_limit: Option<i64>,
    pub swappiness: Option<u64>,
    pub attrs: HashMap<String, String>,
}

Resource limits for the memory subsystem.

Fields

kernel_memory_limit: Option<i64>

How much memory (in bytes) can the kernel consume.

memory_hard_limit: Option<i64>

Upper limit of memory usage of the control group’s tasks.

memory_soft_limit: Option<i64>

How much memory the tasks in the control group can use when the system is under memory pressure.

kernel_tcp_memory_limit: Option<i64>

How much of the kernel’s memory (in bytes) can be used for TCP-related buffers.

memory_swap_limit: Option<i64>

How much memory and swap together can the tasks in the control group use.

swappiness: Option<u64>

Controls the tendency of the kernel to swap out parts of the address space of the tasks to disk. Lower value implies less likely.

Note, however, that a value of zero does not mean the process is never swapped out. Use the traditional mlock(2) system call for that purpose.

attrs: HashMap<String, String>

Customized key-value attributes

Usage:

let resource = &mut cgroups_rs::fs::Resources::default();
resource.memory.attrs.insert("memory.numa_balancing".to_string(), "true".to_string());
// apply here

Trait Implementations

impl Clone for MemoryResources

fn clone(&self) -> MemoryResources

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryResources

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

Formats the value using the given formatter.

impl Default for MemoryResources

fn default() -> MemoryResources

Returns the “default value” for a type.

impl Eq for MemoryResources

impl PartialEq for MemoryResources

fn eq(&self, other: &MemoryResources) -> 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 StructuralPartialEq for MemoryResources