7c615c9f49
This branch adds the ability to define a local JSON file that will hold configuration information that the scheduler can use. This dict will be passed into the filter and weighing functions so that Operations can tweak the scheduler without having to bring down the scheduler service. Currently the polling time on the file is hardcoded at 5 minutes, but certainly this could be made into a flag. Next update will be to remove the host_filter and weighing_functions flags and fix the scheduler to get these values from the config file. Change-Id: Ia2487e933483761276058689fad84564d96a451e
123 lines
4.4 KiB
Python
123 lines
4.4 KiB
Python
# Copyright (c) 2011 Openstack, LLC.
|
|
# 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.
|
|
"""
|
|
Least Cost is an algorithm for choosing which host machines to
|
|
provision a set of resources to. The input is a WeightedHost object which
|
|
is decided upon by a set of objective-functions, called the 'cost-functions'.
|
|
The WeightedHost contains a combined weight for each cost-function.
|
|
|
|
The cost-function and weights are tabulated, and the host with the least cost
|
|
is then selected for provisioning.
|
|
"""
|
|
|
|
|
|
from nova import flags
|
|
from nova import log as logging
|
|
from nova import exception
|
|
|
|
LOG = logging.getLogger('nova.scheduler.least_cost')
|
|
|
|
FLAGS = flags.FLAGS
|
|
flags.DEFINE_list('least_cost_functions',
|
|
['nova.scheduler.least_cost.compute_fill_first_cost_fn'],
|
|
'Which cost functions the LeastCostScheduler should use.')
|
|
|
|
|
|
# TODO(sirp): Once we have enough of these rules, we can break them out into a
|
|
# cost_functions.py file (perhaps in a least_cost_scheduler directory)
|
|
flags.DEFINE_float('noop_cost_fn_weight', 1.0,
|
|
'How much weight to give the noop cost function')
|
|
flags.DEFINE_float('compute_fill_first_cost_fn_weight', 1.0,
|
|
'How much weight to give the fill-first cost function')
|
|
|
|
|
|
class WeightedHost(object):
|
|
"""Reduced set of information about a host that has been weighed.
|
|
This is an attempt to remove some of the ad-hoc dict structures
|
|
previously used."""
|
|
|
|
def __init__(self, weight, host=None, blob=None, zone=None, hostinfo=None):
|
|
self.weight = weight
|
|
self.blob = blob
|
|
self.host = host
|
|
self.zone = zone
|
|
|
|
# Local members. These are not returned outside of the Zone.
|
|
self.hostinfo = hostinfo
|
|
|
|
def to_dict(self):
|
|
x = dict(weight=self.weight)
|
|
if self.blob:
|
|
x['blob'] = self.blob
|
|
if self.host:
|
|
x['host'] = self.host
|
|
if self.zone:
|
|
x['zone'] = self.zone
|
|
return x
|
|
|
|
|
|
def noop_cost_fn(host_info, options=None):
|
|
"""Return a pre-weight cost of 1 for each host"""
|
|
return 1
|
|
|
|
|
|
def compute_fill_first_cost_fn(host_info, options=None):
|
|
"""More free ram = higher weight. So servers will less free
|
|
ram will be preferred."""
|
|
return host_info.free_ram_mb
|
|
|
|
|
|
def weighted_sum(weighted_fns, host_list, options):
|
|
"""Use the weighted-sum method to compute a score for an array of objects.
|
|
Normalize the results of the objective-functions so that the weights are
|
|
meaningful regardless of objective-function's range.
|
|
|
|
host_list - [(host, HostInfo()), ...]
|
|
weighted_fns - list of weights and functions like:
|
|
[(weight, objective-functions), ...]
|
|
options is an arbitrary dict of values.
|
|
|
|
Returns a single WeightedHost object which represents the best
|
|
candidate.
|
|
"""
|
|
|
|
# Make a grid of functions results.
|
|
# One row per host. One column per function.
|
|
scores = []
|
|
for weight, fn in weighted_fns:
|
|
scores.append([fn(host_info, options) for hostname, host_info
|
|
in host_list])
|
|
|
|
# Adjust the weights in the grid by the functions weight adjustment
|
|
# and sum them up to get a final list of weights.
|
|
adjusted_scores = []
|
|
for (weight, fn), row in zip(weighted_fns, scores):
|
|
adjusted_scores.append([weight * score for score in row])
|
|
|
|
# Now, sum down the columns to get the final score. Column per host.
|
|
final_scores = [0.0] * len(host_list)
|
|
for row in adjusted_scores:
|
|
for idx, col in enumerate(row):
|
|
final_scores[idx] += col
|
|
|
|
# Super-impose the hostinfo into the scores so
|
|
# we don't lose it when we sort.
|
|
final_scores = [(final_scores[idx], host_tuple)
|
|
for idx, host_tuple in enumerate(host_list)]
|
|
|
|
final_scores = sorted(final_scores)
|
|
weight, (host, hostinfo) = final_scores[0] # Lowest score is the winner!
|
|
return WeightedHost(weight, host=host, hostinfo=hostinfo)
|