k8s_openapi/v1_37/api/resource/v1beta1/
node_allocatable_resource.rs

1// Generated from definition io.k8s.api.resource.v1beta1.NodeAllocatableResource
2
3/// NodeAllocatableResource defines the translation between the DRA device/capacity units requested to the corresponding quantity of the node allocatable resource. At least one of Mapping or Overhead must be specified. Not specifying either is an invalid configuration.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct NodeAllocatableResource {
6    /// Mapping is used when the device directly models a node allocatable resource like standard CPU or memory (e.g., with a CPU DRA driver). The calculated quantity is accounted for exactly once per claim instance on the node. To prevent node cgroup isolation friction, the scheduler explicitly blocks sharing mapped device claims across multiple pods.
7    pub mapping: Option<crate::api::resource::v1beta1::NodeAllocatableMapping>,
8
9    /// Overhead contains fields for modeling auxiliary overhead incurred on node allocatable resources when allocating devices that are not themselves modeling a node allocatable resource (e.g., host memory overhead for GPUs). Sharing overhead-mapped claims across multiple pods is allowed. The node allocatable overhead is accounted for individually for each pod referencing the claim. Overhead is always subtracted from the node's allocatable capacity for the resource, even when mapping is specified for the same resource. Eg: If a device models memory capacity per socket as a consumable capacity pool via Mapping (with CapacityKey), any overhead specified for the same resource will be subtracted from the node's general allocatable capacity and not from the per-socket capacity pool in Mapping.
10    pub overhead: Option<crate::api::resource::v1beta1::NodeAllocatableOverhead>,
11}
12
13impl crate::DeepMerge for NodeAllocatableResource {
14    fn merge_from(&mut self, other: Self) {
15        crate::DeepMerge::merge_from(&mut self.mapping, other.mapping);
16        crate::DeepMerge::merge_from(&mut self.overhead, other.overhead);
17    }
18}
19
20impl<'de> crate::serde::Deserialize<'de> for NodeAllocatableResource {
21    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
22        #[allow(non_camel_case_types)]
23        enum Field {
24            Key_mapping,
25            Key_overhead,
26            Other,
27        }
28
29        impl<'de> crate::serde::Deserialize<'de> for Field {
30            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
31                struct Visitor;
32
33                impl crate::serde::de::Visitor<'_> for Visitor {
34                    type Value = Field;
35
36                    fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
37                        f.write_str("field identifier")
38                    }
39
40                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
41                        Ok(match v {
42                            "mapping" => Field::Key_mapping,
43                            "overhead" => Field::Key_overhead,
44                            _ => Field::Other,
45                        })
46                    }
47                }
48
49                deserializer.deserialize_identifier(Visitor)
50            }
51        }
52
53        struct Visitor;
54
55        impl<'de> crate::serde::de::Visitor<'de> for Visitor {
56            type Value = NodeAllocatableResource;
57
58            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
59                f.write_str("NodeAllocatableResource")
60            }
61
62            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
63                let mut value_mapping: Option<crate::api::resource::v1beta1::NodeAllocatableMapping> = None;
64                let mut value_overhead: Option<crate::api::resource::v1beta1::NodeAllocatableOverhead> = None;
65
66                while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
67                    match key {
68                        Field::Key_mapping => value_mapping = crate::serde::de::MapAccess::next_value(&mut map)?,
69                        Field::Key_overhead => value_overhead = crate::serde::de::MapAccess::next_value(&mut map)?,
70                        Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
71                    }
72                }
73
74                Ok(NodeAllocatableResource {
75                    mapping: value_mapping,
76                    overhead: value_overhead,
77                })
78            }
79        }
80
81        deserializer.deserialize_struct(
82            "NodeAllocatableResource",
83            &[
84                "mapping",
85                "overhead",
86            ],
87            Visitor,
88        )
89    }
90}
91
92impl crate::serde::Serialize for NodeAllocatableResource {
93    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
94        let mut state = serializer.serialize_struct(
95            "NodeAllocatableResource",
96            self.mapping.as_ref().map_or(0, |_| 1) +
97            self.overhead.as_ref().map_or(0, |_| 1),
98        )?;
99        if let Some(value) = &self.mapping {
100            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "mapping", value)?;
101        }
102        if let Some(value) = &self.overhead {
103            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "overhead", value)?;
104        }
105        crate::serde::ser::SerializeStruct::end(state)
106    }
107}
108
109#[cfg(feature = "schemars")]
110impl crate::schemars::JsonSchema for NodeAllocatableResource {
111    fn schema_name() -> std::borrow::Cow<'static, str> {
112        "io.k8s.api.resource.v1beta1.NodeAllocatableResource".into()
113    }
114
115    fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
116        crate::schemars::json_schema!({
117            "description": "NodeAllocatableResource defines the translation between the DRA device/capacity units requested to the corresponding quantity of the node allocatable resource. At least one of Mapping or Overhead must be specified. Not specifying either is an invalid configuration.",
118            "type": "object",
119            "properties": {
120                "mapping": ({
121                    let mut schema_obj = __gen.subschema_for::<crate::api::resource::v1beta1::NodeAllocatableMapping>();
122                    schema_obj.ensure_object().insert("description".into(), "Mapping is used when the device directly models a node allocatable resource like standard CPU or memory (e.g., with a CPU DRA driver). The calculated quantity is accounted for exactly once per claim instance on the node. To prevent node cgroup isolation friction, the scheduler explicitly blocks sharing mapped device claims across multiple pods.".into());
123                    schema_obj
124                }),
125                "overhead": ({
126                    let mut schema_obj = __gen.subschema_for::<crate::api::resource::v1beta1::NodeAllocatableOverhead>();
127                    schema_obj.ensure_object().insert("description".into(), "Overhead contains fields for modeling auxiliary overhead incurred on node allocatable resources when allocating devices that are not themselves modeling a node allocatable resource (e.g., host memory overhead for GPUs). Sharing overhead-mapped claims across multiple pods is allowed. The node allocatable overhead is accounted for individually for each pod referencing the claim. Overhead is always subtracted from the node's allocatable capacity for the resource, even when mapping is specified for the same resource. Eg: If a device models memory capacity per socket as a consumable capacity pool via Mapping (with CapacityKey), any overhead specified for the same resource will be subtracted from the node's general allocatable capacity and not from the per-socket capacity pool in Mapping.".into());
128                    schema_obj
129                }),
130            },
131        })
132    }
133}
k8s_openapi/v1_37/api/resource/v1beta1/node_allocatable_resource.rs

k8s_openapi/v1_37/api/resource/v1beta1/
node_allocatable_resource.rs
