Struct NodeAllocatableMapping 

pub struct NodeAllocatableMapping {
    pub capacity_key: Option<String>,
    pub capacity_multiplier: Option<Quantity>,
    pub device_multiplier: Option<Quantity>,
}

NodeAllocatableMapping defines how a DRA allocation directly translates into a node allocatable resource quantity. The mapping can be derived from either the count of allocated devices or the specific capacity consumed. These options are mutually exclusive. Kubelet adds this mapped resource quantity from claim to both requests and limits at the pod-level cgroup, and to limits at the container-level cgroup for each container referencing the claim.

Fields

capacity_key: Option<String>

CapacityKey references a capacity name defined as a key in the spec.devices\[*\].capacity map. When this field is set, the value associated with this key in the status.allocation.devices.results\[*\].consumedCapacity map (for a specific claim allocation) determines the base quantity for the node allocatable resource. capacityMultiplier must also be set and is multiplied with the base quantity. For example, if spec.devices\[*\].capacity has an entry “dra.example.com/memory”: “128Gi”, and this field is set to “dra.example.com/memory”, then for a claim allocation that consumes { “dra.example.com/memory”: “4Gi” } the base quantity for the node allocatable resource mapping will be “4Gi”. The final node allocatable resource amount is consumedCapacity\[capacityKey\] * capacityMultiplier.

capacity_multiplier: Option<Quantity>

CapacityMultiplier is used as a multiplier for the allocated capacity consumed. It is only valid if capacityKey is set. The final node allocatable resource amount is consumedCapacity\[capacityKey\] * capacityMultiplier. For example, if a Device’s capacity “dra.example.com/cores” is consumed, and each “core” provides 2 “cpu“s, the mapping would be: {ResourceName: “cpu”, capacityKey: “dra.example.com/cores”, capacityMultiplier: “2”}. If a claim consumes 8 “dra.example.com/cores”, the CPU footprint is 8 * 2 = 16.

device_multiplier: Option<Quantity>

DeviceMultiplier is used as a multiplier for the allocated device count in the claim. The final node allocatable resource amount is deviceCount * deviceMultiplier. For example, a DRA driver representing each cache complex (CCX) as a device would have {ResourceName: “cpu”, deviceMultiplier: “8”} in its nodeAllocatableResources. If 2 devices (CCX) are allocated to the claim, 2 * 8 = 16 CPUs would be considered as allocated. It is only valid when capacityKey and capacityMultiplier are not set.

Trait Implementations

impl Clone for NodeAllocatableMapping

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeAllocatableMapping

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

Formats the value using the given formatter.

impl DeepMerge for NodeAllocatableMapping

fn merge_from(&mut self, other: Self)

Merge other into self.

impl Default for NodeAllocatableMapping

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NodeAllocatableMapping

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NodeAllocatableMapping

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for NodeAllocatableMapping

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for NodeAllocatableMapping