Struct ResourceLimits 

pub struct ResourceLimits {
    pub memory_bytes: Option<u64>,
    pub memory_high: Option<u64>,
    pub memory_swap_max: Option<u64>,
    pub cpu_quota_us: Option<u64>,
    pub cpu_period_us: u64,
    pub cpu_weight: Option<u64>,
    pub pids_max: Option<u64>,
    pub io_limits: Vec<IoDeviceLimit>,
    pub memlock_bytes: Option<u64>,
}

Resource limits configuration

Fields

memory_bytes: Option<u64>

Memory limit in bytes (None = unlimited)

memory_high: Option<u64>

Memory soft limit in bytes (auto-set to 90% of memory_bytes)

memory_swap_max: Option<u64>

Swap limit in bytes (Some(0) = disable swap)

cpu_quota_us: Option<u64>

CPU quota in microseconds per period

cpu_period_us: u64

CPU period in microseconds (default: 100000 = 100ms)

cpu_weight: Option<u64>

CPU scheduling weight (1-10000)

pids_max: Option<u64>

Maximum number of PIDs (None = unlimited)

io_limits: Vec<IoDeviceLimit>

Per-device I/O limits

memlock_bytes: Option<u64>

RLIMIT_MEMLOCK in bytes (None = use default 64KB). io_uring requires a larger limit (e.g. 8M) for ring buffers.

Implementations

impl ResourceLimits

pub fn unlimited() -> Self

Create unlimited resource limits

pub fn parse_memory(s: &str) -> Result<u64>

Parse memory limit from string (e.g., “512M”, “1G”)

pub fn with_memory(self, limit: &str) -> Result<Self>

Set memory limit from string (e.g., “512M”, “1G”)

Automatically sets memory_high to 90% of the hard limit and disables swap (memory_swap_max = 0) unless swap was explicitly enabled.

pub fn with_swap_enabled(self) -> Self

Enable swap (removes the default swap=0 restriction)

pub fn with_cpu_cores(self, cores: f64) -> Result<Self>

Set CPU limit in cores (e.g., 2.5 cores)

pub fn with_pids(self, max_pids: u64) -> Result<Self>

Set maximum number of PIDs

pub fn with_cpu_weight(self, weight: u64) -> Result<Self>

Set CPU scheduling weight (1-10000)

pub fn with_io_limit(self, limit: IoDeviceLimit) -> Self

Add an I/O device limit

pub fn with_memlock(self, limit: &str) -> Result<Self>

Set RLIMIT_MEMLOCK (e.g. “8M” for io_uring ring buffers)

Trait Implementations

impl Clone for ResourceLimits

fn clone(&self) -> ResourceLimits

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResourceLimits

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

Formats the value using the given formatter.

impl Default for ResourceLimits

fn default() -> Self

Returns the “default value” for a type.