e5ba849437
The weight system is being used by the scheduler and the cells code.
Currently this system is using the raw values instead of normalizing them.
This makes difficult to properly use multipliers for establishing the
relative importance between two wheighers (one big magnitude could
shade a smaller one). This change introduces weight normalization so
that:
- From an operator point of view we can prioritize the weighers that
we are applying. The only way to do this is being sure that all the
weighers will give a value in a known range, so that it is
not needed to artificially use a huge multiplier to prioritize a
weigher.
- From a weigher developer point of view, somebody willing to implement
one has to care about 1) returning a list of values, 2) setting the
minimum and maximum values where the weights can range, if they are
needed and they are significant for the weighing. For a weigher
developer there are two use cases:
Case 1: Use of a percentage instead of absolute values (for example, %
of free RAM). If we compare two nodes focusing on the percentage of free
ram, the maximum value for the weigher is 100. If we have two nodes one
with 2048 total/1024 free, and the second one 1024 total/512 free they
will get both the same weight, since they have the same % of free RAM
(that is, the 50%).
Case 2: Use of absolute values. In this case, the maximum of the weigher
will be the maximum of the values in the list (in the case above, 1024)
or the maximum value that the magnitude could take (in the case above,
2048). How this maximum is set, is a decision of the developer. He may
let the operator choose the behaviour of the weigher though.
- From the point of view of the scheduler we ensure that it is using
normalized values, and not leveraging the normalization mechanism to the
weighers.
Changes introduced this commit:
1) it introduces weight normalization so that we can apply multipliers
easily. All the weights for an object will be normalized between 0.0 and
1.0 before being sumed up, so that the final weight for a host will be:
weight = w1_multiplier * norm(w1) + w2_multiplier * norm(w2) + ...
2) weights.BaseWeigher has been changed into an ABC so that we enforce
that all weighers have the expected methods.
3) weights.BaseWeigher.weigh_objects() does no longer sum up the
computer weighs to the object, but it rather returns a list that will be
then normalized and added to the existing weight by BaseWeightHandler
4) Adapt the existing weighers to the above changes. Namely
- New 'offset_weight_multiplier' for the cell weigher
nova.cells.weights.weight_offset.WeightOffsetWeigher
- Changed the name of the existing multiplier methods.
5) unittests for all of the introduced changes.
Implements blueprint normalize-scheduler-weights
DocImpact: Now weights for an object are normalized before suming them
up. This means that each weigher will take a maximum value of 1. This
may have an impact for operators that are using more than one weigher
(currently there is only one weigher: RAMWeiger) and for operators using
cells (where we have several weighers). It is needed to review then the
multipliers used and adjust them properly in case they have been
modified.
Docimpact: There is a new configuration option 'offset_weight_multiplier'
in nova.cells.weights.weight_offset.WeightOffsetWeigher
Change-Id: I81bf90898d3cb81541f4390596823cc00106eb20
55 lines
1.9 KiB
Python
55 lines
1.9 KiB
Python
# Copyright 2011-2012 OpenStack Foundation
|
|
# All Rights Reserved.
|
|
#
|
|
# 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.
|
|
"""
|
|
Tests For weights.
|
|
"""
|
|
|
|
from nova import test
|
|
from nova import weights
|
|
|
|
|
|
class TestWeigher(test.NoDBTestCase):
|
|
def test_no_multiplier(self):
|
|
class FakeWeigher(weights.BaseWeigher):
|
|
def _weigh_object(self, *args, **kwargs):
|
|
pass
|
|
|
|
self.assertEqual(1.0,
|
|
FakeWeigher().weight_multiplier())
|
|
|
|
def test_no_weight_object(self):
|
|
class FakeWeigher(weights.BaseWeigher):
|
|
def weight_multiplier(self, *args, **kwargs):
|
|
pass
|
|
self.assertRaises(TypeError,
|
|
FakeWeigher)
|
|
|
|
def test_normalization(self):
|
|
# weight_list, expected_result, minval, maxval
|
|
map_ = (
|
|
((), (), None, None),
|
|
((0.0, 0.0), (0.0, 0.0), None, None),
|
|
((1.0, 1.0), (0.0, 0.0), None, None),
|
|
|
|
((20.0, 50.0), (0.0, 1.0), None, None),
|
|
((20.0, 50.0), (0.0, 0.375), None, 100.0),
|
|
((20.0, 50.0), (0.4, 1.0), 0.0, None),
|
|
((20.0, 50.0), (0.2, 0.5), 0.0, 100.0),
|
|
)
|
|
normalize_to = (1.0, 10.0)
|
|
for seq, result, minval, maxval in map_:
|
|
ret = weights.normalize(seq, minval=minval, maxval=maxval)
|
|
self.assertEqual(tuple(ret), result)
|