Enum HugePage

pub enum HugePage {
    Static(MapHugeFlag),
    Dynamic {
        kilobytes: usize,
    },
    Smallest,
    Largest,
    Selected(for<'r> fn(&'r [usize]) -> Option<&'r usize>),
}

Provides an arbitrary huge-page size and mapping flag for that size.

Can store or create a MAP_HUGE_* flag for use with mmap(), (MappedFile) or memfd_create() (file::MemoryFile::with_hugetlb())

Usage

Main usage is for generating a MapHugeFlag via compute_huge(). This function may fail (rarely), so a TryInto impl exists for MapHugeFlag as well.

Variants

Static(MapHugeFlag)

A staticly presented MAP_HUGE_* flag. See MapHugeFlag for details.

Dynamic

A dynamically calculated MAP_HUGE_* flag from an arbitrary size in kB.

Safety

The kernel must actually support huge-pages of this size.

If kilobytes is 0, or an overflow in calculation happens, then this is identical to Smallest.

Fields

kilobytes: usize

Smallest

The smallest huge-page size on the system

Largest

The largest huge-page size on the system

Selected(for<'r> fn(&'r [usize]) -> Option<&'r usize>)

Use a callback function to select the huge-page size (in kB) from an ordered (lowest to highest) enumeration of all available on the system.

Implementations

impl HugePage

pub fn compute_huge(self) -> Option<MapHugeFlag>

Compute the MapHugeFlag from this huge-page specification.

Returns

• None - If there was an error in computing the correct flag.
• Some - If the computation was successful.

Panics

In debug builds, if scanning the system for huge-pages fails after SYSTEM_HUGEPAGES has already failed.

Trait Implementations

impl Clone for HugePage

fn clone(&self) -> HugePage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HugePage

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

Formats the value using the given formatter.

impl Default for HugePage

fn default() -> HugePage

Returns the “default value” for a type.

impl Hash for HugePage

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for HugePage

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

Tests for self and other values to be equal, and is used by ==.

const 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 TryFrom<HugePage> for MapHugeFlag

type Error = HugePageCalcErr

The type returned in the event of a conversion error.

fn try_from(from: HugePage) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for HugePage

impl Eq for HugePage