From 01c1767655bc383ffce212f770a4ade5c2339472 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Tom=C3=A1s=20Villaseca?= Date: Wed, 5 Feb 2020 18:13:52 -0300 Subject: [PATCH] Add EPA augment MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Change-Id: I507c26dc490f57e5552755fb0d47fb9b23d04612 Signed-off-by: Tomás Villaseca --- augments/epa.yang | 262 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 262 insertions(+) create mode 100644 augments/epa.yang diff --git a/augments/epa.yang b/augments/epa.yang new file mode 100644 index 0000000..d47d6a9 --- /dev/null +++ b/augments/epa.yang @@ -0,0 +1,262 @@ +/* + 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; + } +} \ No newline at end of file -- 2.25.1