/* Copyright 2020 Whitestack LLC Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ module epa { yang-version 1.1; namespace "urn:etsi:osm:yang:augments:epa"; prefix "epa"; import etsi-nfv-vnfd { prefix vnfd; } grouping allocation-properties { leaf limit { description "Defines the maximum allocation. The value 0 indicates that usage is not limited. This parameter ensures that the instance never uses more than the defined amount of resource."; type uint64; } leaf reserve { description "Defines the guaranteed minimum reservation. If needed, the machine will definitely get allocated the reserved amount of resources."; type uint64; } leaf shares { description "Number of shares allocated. Specifies the proportional weighted share for the domain. If this element is omitted, the service defaults to the OS provided defaults"; type uint64; } } grouping extended-mem-quota { container mem-quota { description "Memory quota describes the memory resource allocation policy. Limit and Reserve values are defined in MB"; uses allocation-properties; } } grouping extended-vif-quota { container vif-quota { description "Virtual interfaces quota describes the virtual interface bandwidth resource allocation policy. Limit and Reserve values are defined in Mbps"; uses allocation-properties; } } grouping extended-disk-io-quota { container disk-io-quota { description "Disk IO quota describes the disk IO operations resource allocation policy. Limit and Reserve values are defined in IOPS"; uses allocation-properties; } } grouping extended-cpu-quota { container cpu-quota { description "CPU quota describes the CPU resource allocation policy. Limit and Reserve values are defined in MHz"; uses allocation-properties; } } grouping extended-cpu-policy { leaf thread-policy { description "CPU thread pinning policy describes how to place the guest CPUs when the host supports hyper threads: AVOID : Avoids placing a guest on a host with threads. SEPARATE: Places vCPUs on separate cores, and avoids placing two vCPUs on two threads of same core. ISOLATE : Places each vCPU on a different core, and places no vCPUs from a different guest on the same core. PREFER : Attempts to place vCPUs on threads of the same core."; type enumeration { enum AVOID; enum SEPARATE; enum ISOLATE; enum PREFER; } } } grouping extended-mempage-size { leaf mempage-size { description "Memory page allocation size. If a VM requires hugepages, it should choose LARGE or SIZE_2MB or SIZE_1GB. If the VM prefers hugepages it should choose PREFER_LARGE. LARGE : Require hugepages (either 2MB or 1GB) SMALL : Doesn't require hugepages SIZE_2MB : Requires 2MB hugepages SIZE_1GB : Requires 1GB hugepages PREFER_LARGE : Application prefers hugepages"; type enumeration { enum LARGE; enum SMALL; enum SIZE_2MB; enum SIZE_1GB; enum PREFER_LARGE; } } } grouping extended-numa { container numa-node-policy { description "This policy defines NUMA topology of the guest. Specifically identifies if the guest should be run on a host with one NUMA node or multiple NUMA nodes. As an example a guest might need 8 VCPUs and 4 GB of memory. However, it might need the VCPUs and memory distributed across multiple NUMA nodes. In this scenario, NUMA node 1 could run with 6 VCPUs and 3GB, and NUMA node 2 could run with 2 VCPUs and 1GB."; leaf node-cnt { description "The number of NUMA nodes to expose to the VM."; type uint16; } leaf mem-policy { description "This policy specifies how the memory should be allocated in a multi-node scenario. STRICT : The memory must be allocated strictly from the memory attached to the NUMA node. PREFERRED : The memory should be allocated preferentially from the memory attached to the NUMA node"; type enumeration { enum STRICT; enum PREFERRED; } } list node { key id; leaf id { description "NUMA node identification. Typically it's 0 or 1"; type uint64; } list vcpu { key "id"; description "List of VCPUs to allocate on this NUMA node."; leaf id { type uint64; description "List of VCPUs ids to allocate on this NUMA node"; } } leaf memory-mb { description "Memory size expressed in MB for this NUMA node."; type uint64; } choice om-numa-type { description "OpenMANO Numa type selection"; case cores { leaf num-cores { type uint8; } } case paired-threads { container paired-threads { leaf num-paired-threads { type uint8; } list paired-thread-ids { description "List of thread pairs to use in case of paired-thread NUMA"; max-elements 16; key thread-a; leaf thread-a { type uint8; } leaf thread-b { type uint8; } } } } case threads { leaf num-threads { type uint8; } } } } } } augment "/vnfd:vnfd/vnfd:virtual-compute-desc/vnfd:virtual-memory" { uses extended-numa; uses extended-mempage-size; uses extended-mem-quota; } augment "/vnfd:vnfd/vnfd:virtual-compute-desc/vnfd:virtual-cpu/vnfd:pinning" { uses extended-cpu-policy; } augment "/vnfd:vnfd/vnfd:virtual-compute-desc/vnfd:virtual-cpu" { uses extended-cpu-quota; } augment "/vnfd:vnfd/vnfd:virtual-storage-desc" { uses extended-disk-io-quota; } augment "/vnfd:vnfd/vnfd:vdu/vnfd:int-cpd/vnfd:virtual-network-interface-requirement" { uses extended-vif-quota; } }