Enum CacheLevel

pub enum CacheLevel {
    L1,
    L2,
    L3,
    L4,
    Unknown,
}

Represents the hierarchical level of a CPU cache within the memory system.

CPU caches are organized in levels, typically denoted as L1, L2, L3, and sometimes L4. These levels indicate the cache’s proximity to the CPU core, its size, and its speed. Generally, lower levels are faster, smaller, and closer to the core, while higher levels are slower, larger, and often shared among multiple cores.

Variants

L1

Level 1 (L1) cache.

This is the fastest and smallest cache, located closest to the CPU core. L1 caches are typically split into separate caches for instructions (L1i) and data (L1d) for each core.

L2

Level 2 (L2) cache.

L2 cache is larger and slower than L1 but faster than L3. It’s often dedicated to a single CPU core, though some architectures might share it between a small group of cores.

L3

Level 3 (L3) cache.

L3 cache, also known as the Last-Level Cache (LLC) in many systems, is larger and slower than L2. It is typically shared among all cores on a CPU socket or die. It serves as a common pool of frequently accessed data for all cores.

L4

Level 4 (L4) cache.

L4 cache is less common but can be found in some high-end CPUs or specific architectures (e.g., as an eDRAM cache). It acts as an additional layer beyond L3, often shared across multiple sockets or as a victim cache.

Unknown

Represents an unknown or unspecified cache level.

This variant is used when the cache level cannot be determined or does not fit into the standard L1-L4 classification.

Trait Implementations

impl Clone for CacheLevel

fn clone(&self) -> CacheLevel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheLevel

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

Formats the value using the given formatter.

impl Display for CacheLevel

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

Formats the value using the given formatter.

impl From<u32> for CacheLevel

fn from(level: u32) -> Self

Converts to this type from the input type.

impl Hash for CacheLevel

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 CacheLevel

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

impl Eq for CacheLevel

impl StructuralPartialEq for CacheLevel