Struct re_memory::MemoryLimit

pub struct MemoryLimit {
    pub max_bytes: Option<i64>,
}

Represents a limit in how much RAM to use for the entire process.

Different systems can chose to heed the memory limit in different ways, e.g. by dropping old data when it is exceeded.

It is recommended that they log using [re_log::info_once] when they drop data because a memory limit is reached.

Fields

max_bytes: Option<i64>

Limit in bytes.

This is primarily compared to what is reported by crate::AccountingAllocator (‘counted’). We limit based on this instead of resident (RSS) because counted is what we have immediate control over, while RSS depends on what our allocator (MiMalloc) decides to do.

Implementations

impl MemoryLimit

pub const UNLIMITED: Self = _

No limit.

pub fn from_bytes(max_bytes: u64) -> Self

Set the limit to some number of bytes.

pub fn from_fraction_of_total(fraction: f32) -> Self

Set the limit to some fraction (0-1) of the total available RAM.

pub fn parse(limit: &str) -> Result<Self, String>

The limit can either be absolute (e.g. “16GB”) or relative (e.g. “50%”).

pub fn is_limited(&self) -> bool

pub fn is_unlimited(&self) -> bool

pub fn is_exceeded_by(&self, mem_use: &MemoryUse) -> Option<f32>

Returns how large fraction of memory we should free to go down to the exact limit.

Trait Implementations

impl Clone for MemoryLimit

fn clone(&self) -> MemoryLimit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryLimit

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

Formats the value using the given formatter.

impl PartialEq for MemoryLimit

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for MemoryLimit

impl Eq for MemoryLimit

impl StructuralPartialEq for MemoryLimit