"No value specified for property '{}' in "
"constraint named '{}'".format(
req_prop, name))
- # For HPA constraints
+ # For HPA constraints
if constraint_type == 'hpa':
self.validate_hpa_constraints(req_prop, value)
elif product_op.keys() == ['aic_version']:
function = 'aic_version'
args = product_op.get('aic_version')
+ elif product_op.keys() == ['hpa_score']:
+ function = 'hpa_score'
+ args = product_op.get('hpa_score')
+ if not self.is_hpa_policy_exists(args):
+ raise TranslatorException(
+ "HPA Score Optimization must include a "
+ "HPA Policy constraint ")
elif product_op.keys() == ['sum']:
nested = True
nested_operands = product_op.get('sum')
)
return parsed
+ def is_hpa_policy_exists(self, demand_list):
+ # Check if a HPA constraint exist for the demands in the demand list.
+ constraints_copy = copy.deepcopy(self._constraints)
+ for demand in demand_list:
+ for name, constraint in constraints_copy.items():
+ constraint_type = constraint.get('type')
+ if constraint_type == 'hpa':
+ hpa_demands = constraint.get('demands')
+ if demand in hpa_demands:
+ return True
+ return False
+
def parse_reservations(self, reservations):
demands = self._demands
if type(reservations) is not dict:
"request_type": request_type,
"locations": self.parse_locations(self._locations),
"demands": self.parse_demands(self._demands),
- "objective": self.parse_optimization(self._optmization),
"constraints": self.parse_constraints(self._constraints),
"objective": self.parse_optimization(self._optmization),
"reservations": self.parse_reservations(self._reservations),
if score > max_score:
max_score = score
flavor_map = {"flavor-id": flavor['flavor-id'],
- "flavor-name": flavor['flavor-name']}
+ "flavor-name": flavor['flavor-name'],
+ "score": max_score}
return flavor_map
# Create flavor mapping for label_name to flavor
flavor_name = flavor_info.get("flavor-name")
candidate["flavor_map"][label_name] = flavor_name
+ # If hpa_score is not defined then initialize value 0
+ # hpa_score = sum of scores of each vnfc hpa requirement score
+ if not candidate.get("hpa_score"):
+ candidate["hpa_score"] = 0
+ candidate["hpa_score"] += flavor_info.get("score")
# return candidates not in discard set
candidate_list[:] = [c for c in candidate_list
--- /dev/null
+#!/usr/bin/env python
+#
+# -------------------------------------------------------------------------
+# Copyright (c) 2018 Intel Corporation Intellectual Property
+#
+# 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.
+#
+# -------------------------------------------------------------------------
+#
+
+'''Objective function for hpa_score
+ Hardware Platform Awareness (HPA)'''
+
+
+class HPAScore(object):
+
+ def __init__(self, _type):
+ self.func_type = _type
+ self.score = 0
for demand_name, candidate_info in _decision_path.decisions.items():
value += float(candidate_info['cost'])
+ elif self.function.func_type == "hpa_score":
+ for demand_name, candidate_info in _decision_path.decisions.items():
+ hpa_score = float(candidate_info.get('hpa_score', 0))
+ value += hpa_score
+
if self.operation == "product":
value *= self.weight
from conductor.solver.request.functions import aic_version
from conductor.solver.request.functions import cost
from conductor.solver.request.functions import distance_between
+from conductor.solver.request.functions import hpa_score
from oslo_log import log
# from conductor.solver.request.functions import distance_between
func = cost.Cost("cost")
func.loc = operand_data["function_param"]
operand.function = func
+ elif operand_data["function"] == "hpa_score":
+ func = hpa_score.HPAScore("hpa_score")
+ operand.function = func
self.objective.operand_list.append(operand)
--- /dev/null
+{
+ "HAS_Template": {
+ "constraints": {
+ "hpa_constraint_vG": {
+ "demands": [
+ "vG"
+ ],
+ "name": "hpa_constraint_vG",
+ "type": "hpa",
+ "properties": {
+ "evaluate": [
+ {
+ "flavorProperties": [
+ {
+ "architecture": "generic",
+ "hpa-feature": "basicCapabilities",
+ "hpa-feature-attributes": [
+ {
+ "hpa-attribute-key": "numVirtualCpu",
+ "hpa-attribute-value": "4",
+ "operator": "="
+ },
+ {
+ "hpa-attribute-key": "virtualMemSize",
+ "hpa-attribute-value": "4",
+ "operator": "=",
+ "unit": "GB"
+ }
+ ],
+ "hpa-version": "v1"
+ },
+ {
+ "architecture": "generic",
+ "hpa-feature": "numa",
+ "hpa-feature-attributes": [
+ {
+ "hpa-attribute-key": "numaNodes",
+ "hpa-attribute-value": "2",
+ "operator": "="
+ },
+ {
+ "hpa-attribute-key": "numaCpu-0",
+ "hpa-attribute-value": "2",
+ "operator": "="
+ },
+ {
+ "hpa-attribute-key": "numaCpu-1",
+ "hpa-attribute-value": "4",
+ "operator": "="
+ },
+ {
+ "hpa-attribute-key": "numaMem-0",
+ "hpa-attribute-value": "2",
+ "operator": "=",
+ "unit": "GB"
+ },
+ {
+ "hpa-attribute-key": "numaMem-1",
+ "hpa-attribute-value": "4",
+ "operator": "=",
+ "unit": "GB"
+ }
+ ],
+ "hpa-version": "v1"
+ },
+ {
+ "architecture": "generic",
+ "hpa-feature": "cpuPinning",
+ "hpa-feature-attributes": [
+ {
+ "hpa-attribute-key": "logicalCpuThreadPinningPolicy",
+ "hpa-attribute-value": "prefer",
+ "operator": "="
+ },
+ {
+ "hpa-attribute-key": "logicalCpuPinningPolicy",
+ "hpa-attribute-value": "dedicated",
+ "operator": "="
+ }
+ ],
+ "hpa-version": "v1"
+ }
+ ],
+ "flavorLabel": "flavor_label_1"
+ },
+ {
+ "flavorProperties": [
+ {
+ "architecture": "generic",
+ "hpa-feature": "basicCapabilities",
+ "hpa-feature-attributes": [
+ {
+ "hpa-attribute-key": "numVirtualCpu",
+ "hpa-attribute-value": "8",
+ "operator": "="
+ },
+ {
+ "hpa-attribute-key": "virtualMemSize",
+ "hpa-attribute-value": "16",
+ "operator": "=",
+ "unit": "GB"
+ }
+ ],
+ "hpa-version": "v1"
+ },
+ {
+ "architecture": "generic",
+ "hpa-feature": "numa",
+ "hpa-feature-attributes": [
+ {
+ "hpa-attribute-key": "numaNodes",
+ "hpa-attribute-value": "2",
+ "operator": "="
+ },
+ {
+ "hpa-attribute-key": "numaCpu-0",
+ "hpa-attribute-value": "2",
+ "operator": "="
+ },
+ {
+ "hpa-attribute-key": "numaCpu-1",
+ "hpa-attribute-value": "4",
+ "operator": "="
+ },
+ {
+ "hpa-attribute-key": "numaMem-0",
+ "hpa-attribute-value": "2",
+ "operator": "=",
+ "unit": "GB"
+ },
+ {
+ "hpa-attribute-key": "numaMem-1",
+ "hpa-attribute-value": "4",
+ "operator": "=",
+ "unit": "GB"
+ }
+ ],
+ "hpa-version": "v1"
+ },
+ {
+ "architecture": "generic",
+ "hpa-feature": "memoryPageSize",
+ "hpa-feature-attributes": [
+ {
+ "hpa-attribute-key": "memoryPageSize",
+ "hpa-attribute-value": "2",
+ "operator": "=",
+ "unit": "GB"
+ }
+ ],
+ "hpa-version": "v1"
+ }
+ ],
+ "flavorLabel": "flavor_label_2"
+ }
+ ]
+ }
+ },
+ "constraint_vgmux_customer": {
+ "type": "distance_to_location",
+ "demands": [
+ "vGMuxInfra"
+ ],
+ "properties": {
+ "distance": "< 100 km",
+ "location": "customer_loc"
+ }
+ },
+ "check_cloud_capacity": {
+ "type": "vim_fit",
+ "demands": [
+ "vG"
+ ],
+ "properties": {
+ "controller": "multicloud",
+ "request": {
+ "vCPU": 10,
+ "Memory": {
+ "quantity": "10",
+ "unit": "GB"
+ },
+ "Storage": {
+ "quantity": "100",
+ "unit": "GB"
+ }
+ }
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
self.Translator.parse_optimization(
opt), expected_parse)
+ @patch('conductor.controller.translator.Translator.create_components')
+ def test_parse_optimization_multi_objective(self, mock_create):
+ hpa_json_file = './conductor/tests/unit/controller/hpa_constraints.json'
+ hpa_json = yaml.safe_load(open(hpa_json_file).read())
+ expected_parse = {'goal': 'min',
+ 'operands': [{'function': 'distance_between',
+ 'function_param': ['customer_loc',
+ 'vGMuxInfra'],
+ 'operation': 'product',
+ 'weight': 2.0},
+ {'function': 'distance_between',
+ 'function_param': ['customer_loc',
+ 'vG'],
+ 'operation': 'product',
+ 'weight': 4.0},
+ {'function': 'hpa_score',
+ 'function_param': ['vG'],
+ 'operation': 'product',
+ 'weight': 8.0},
+ ],
+ 'operation': 'sum'
+ }
+
+ opt = {'minimize': {
+ 'sum': [{'product': [2.0, {'distance_between': ['customer_loc', 'vGMuxInfra']}]},
+ {'product': [4.0, {'distance_between': ['customer_loc', 'vG']}]},
+ {'product': [8.0, {'hpa_score': ['vG']}]}
+ ]}}
+ self.Translator._demands = {'vG': '',
+ 'vGMuxInfra': '',
+ 'customer_loc': ''}
+ self.Translator._locations = {'vG': '',
+ 'vGMuxInfra': '',
+ 'customer_loc': ''}
+ self.Translator._constraints = hpa_json["HAS_Template"]["constraints"]
+ self.maxDiff = None
+ self.assertEquals(
+ self.Translator.parse_optimization(
+ opt), expected_parse)
+
+ # No HPA Policy test
+ non_hpa_dict = dict(hpa_json["HAS_Template"]["constraints"])
+ non_hpa_dict.pop("hpa_constraint_vG")
+ self.Translator._constraints = non_hpa_dict
+ self.maxDiff = None
+ self.assertRaises(TranslatorException,
+ self.Translator.parse_optimization, opt)
+
+ # HPA Policy Exists but not for the demand in objective function
+ hpa_wrong_demand_dict = dict(hpa_json["HAS_Template"]["constraints"])
+ hpa_wrong_demand_dict["hpa_constraint_vG"]["demands"] = ["vGMuxInfra"]
+ self.Translator._constraints = hpa_wrong_demand_dict
+ self.maxDiff = None
+ self.assertRaises(TranslatorException,
+ self.Translator.parse_optimization, opt)
+
@patch('conductor.controller.translator.Translator.create_components')
def test_parse_reservation(self, mock_create):
expected_resv = {'counter': 0, 'demands': {
candidate_json['candidate_list'][1]['flavors'] = flavor_json
flavor_map = {"flavor-id": "f5aa2b2e-3206-41b6-80d5-cf041b098c43",
- "flavor-name": "flavor-cpu-pinning-ovsdpdk-instruction-set"}
+ "flavor-name": "flavor-cpu-pinning-ovsdpdk-instruction-set",
+ "score": 0}
self.assertEqual(flavor_map,
self.aai_ep.match_hpa(candidate_json['candidate_list'][1],
feature_json[0]))
flavor_map = {"flavor-id": "f5aa2b2e-3206-41b6-80d5-cf041b098c43",
- "flavor-name": "flavor-cpu-ovsdpdk-instruction-set" }
+ "flavor-name": "flavor-cpu-ovsdpdk-instruction-set",
+ "score": 10}
self.assertEqual(flavor_map,
self.aai_ep.match_hpa(candidate_json['candidate_list'][1],
feature_json[1]))
label_name = hpa_constraint['evaluate'][0]['flavorLabel']
ext_mock1.return_value = ['aai']
flavor_info = {"flavor-id": "vim-flavor-id1",
- "flavor-name": "vim-flavor-name1"}
+ "flavor-name": "vim-flavor-name1",
+ "score": 0}
hpa_mock.return_value = [flavor_info]
self.maxDiff = None
args = generate_args(candidate_list, flavorProperties, label_name)
hpa_candidate_list = copy.deepcopy(candidate_list)
hpa_candidate_list[1]['flavor_map'] = {}
hpa_candidate_list[1]['flavor_map'][label_name] = "vim-flavor-name1"
+ hpa_candidate_list[1]['hpa_score'] = 0
expected_response = {'response': hpa_candidate_list, 'error': False}
self.assertEqual(expected_response,
self.data_ep.get_candidates_with_hpa(None, args))
Code Review / optf / has.git / commitdiff