Struct NodeAllocatableResourceMapping 

pub struct NodeAllocatableResourceMapping {
    pub allocation_multiplier: Option<Quantity>,
    pub capacity_key: Option<String>,
}

NodeAllocatableResourceMapping defines the translation between the DRA device/capacity units requested to the corresponding quantity of the node allocatable resource.

Fields

allocation_multiplier: Option<Quantity>

AllocationMultiplier is used as a multiplier for the allocated device count or the allocated capacity in the claim. It defaults to 1 if not specified. How the field is used also depends on whether capacityKey is set. 1. If capacityKey is NOT set: allocationMultiplier multiplies the device count allocated to the claim. a. A DRA driver representing each CPU core as a device would have {ResourceName: “cpu”, allocationMultiplier: “2”} in its nodeAllocatableResourceMappings. If 4 devices are allocated to the claim, 4 * 2 CPUs would be considered as allocated and subtracted from the node’s capacity. b. A GPU device that needs additional node memory per GPU allocation would have {ResourceName: “memory”, allocationMultiplier: “2Gi”}. Each allocated GPU device instance of this type will account for 2Gi of memory.

2. If capacityKey IS set: allocationMultiplier is multiplied by the amount of that capacity consumed. The final node allocatable resource amount is consumedCapacity\[capacityKey\] * allocationMultiplier. 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”, allocationMultiplier: “2”}. If a claim consumes 8 “dra.example.com/cores”, the CPU footprint is 8 * 2 = 16.

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. If allocationMultiplier is also set, it 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”, and allocationMultiplier should be omitted or set to “1”.

Trait Implementations

impl Clone for NodeAllocatableResourceMapping

fn clone(&self) -> NodeAllocatableResourceMapping

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeAllocatableResourceMapping

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

Formats the value using the given formatter.

impl DeepMerge for NodeAllocatableResourceMapping

fn merge_from(&mut self, other: Self)

Merge other into self.

impl Default for NodeAllocatableResourceMapping

fn default() -> NodeAllocatableResourceMapping

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NodeAllocatableResourceMapping

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NodeAllocatableResourceMapping

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

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 NodeAllocatableResourceMapping