org.apache.hadoop.hbase.master.balancer

Class StochasticLoadBalancer

java.lang.Object

org.apache.hadoop.hbase.master.balancer.BaseLoadBalancer

org.apache.hadoop.hbase.master.balancer.StochasticLoadBalancer

All Implemented Interfaces:

ConfigurationObserver, LoadBalancer, Stoppable

Direct Known Subclasses:

FavoredStochasticBalancer

@InterfaceAudience.LimitedPrivate(value="Configuration")
public class StochasticLoadBalancer
extends BaseLoadBalancer

This is a best effort load balancer. Given a Cost function F(C) => x It will randomly try and mutate the cluster to Cprime. If F(Cprime) < F(C) then the new cluster state becomes the plan. It includes costs functions to compute the cost of:

• Region Load
• Table Load
• Data Locality
• Memstore Sizes
• Storefile Sizes

Every cost function returns a number between 0 and 1 inclusive; where 0 is the lowest cost best solution, and 1 is the highest possible cost and the worst solution. The computed costs are scaled by their respective multipliers:

• hbase.master.balancer.stochastic.regionLoadCost
• hbase.master.balancer.stochastic.moveCost
• hbase.master.balancer.stochastic.tableLoadCost
• hbase.master.balancer.stochastic.localityCost
• hbase.master.balancer.stochastic.memstoreSizeCost
• hbase.master.balancer.stochastic.storefileSizeCost

You can also add custom Cost function by setting the the following configuration value:

• hbase.master.balancer.stochastic.additionalCostFunctions

All custom Cost Functions needs to extends CostFunction

In addition to the above configurations, the balancer can be tuned by the following configuration values:

• hbase.master.balancer.stochastic.maxMoveRegions which controls what the max number of regions that can be moved in a single invocation of this balancer.
• hbase.master.balancer.stochastic.stepsPerRegion is the coefficient by which the number of regions is multiplied to try and get the number of times the balancer will mutate all servers.
• hbase.master.balancer.stochastic.maxSteps which controls the maximum number of times that the balancer will try and mutate all the servers. The balancer will use the minimum of this value and the above computation.

This balancer is best used with hbase.master.loadbalance.bytable set to false so that the balancer gets the full picture of all loads on the cluster.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	StochasticLoadBalancer.GeneratorType

Field Summary

Fields

Modifier and Type	Field and Description
protected List<CandidateGenerator>	candidateGenerators
protected static String	COST_FUNCTIONS_COST_FUNCTIONS_KEY
private List<CostFunction>	costFunctions
private double[]	curFunctionCosts
private double	curOverallCost
protected static int	DEFAULT_KEEP_REGION_LOADS
protected static long	DEFAULT_MAX_RUNNING_TIME
protected static int	DEFAULT_MAX_STEPS
protected static float	DEFAULT_MIN_COST_NEED_BALANCE
protected static boolean	DEFAULT_RUN_MAX_STEPS
protected static int	DEFAULT_STEPS_PER_REGION
private boolean	isBalancerDecisionRecording
private boolean	isBalancerRejectionRecording
protected static String	KEEP_REGION_LOADS
(package private) Map<String,Deque<BalancerRegionLoad>>	loads
private LocalityBasedCandidateGenerator	localityCandidateGenerator
private ServerLocalityCostFunction	localityCost
private static org.slf4j.Logger	LOG
protected static String	MAX_RUNNING_TIME_KEY
protected static String	MAX_STEPS_KEY
private long	maxRunningTime
private int	maxSteps
protected static String	MIN_COST_NEED_BALANCE_KEY
private float	minCostNeedBalance
(package private) NamedQueueRecorder	namedQueueRecorder Use to add balancer decision history to ring-buffer
private int	numRegionLoadsToRemember
static String	OVERALL_COST_FUNCTION_NAME
private RackLocalityCostFunction	rackLocalityCost
private RegionReplicaHostCostFunction	regionReplicaHostCostFunction
private RegionReplicaRackCostFunction	regionReplicaRackCostFunction
protected static String	RUN_MAX_STEPS_KEY
private boolean	runMaxSteps
protected static String	STEPS_PER_REGION_KEY
private int	stepsPerRegion
private float	sumMultiplier
private static String	TABLE_FUNCTION_SEP
private double[]	tempFunctionCosts
private double[]	weightsOfGenerators

Fields inherited from class org.apache.hadoop.hbase.master.balancer.BaseLoadBalancer

BALANCER_DECISION_BUFFER_ENABLED, BALANCER_REJECTION_BUFFER_ENABLED, clusterStatus, DEFAULT_BALANCER_DECISION_BUFFER_ENABLED, DEFAULT_BALANCER_REJECTION_BUFFER_ENABLED, DEFAULT_HBASE_MASTER_LOADBALANCE_BYTABLE, isByTable, masterServerName, metricsBalancer, MIN_SERVER_BALANCE, onlySystemTablesOnMaster, rackManager, regionFinder, services, slop, useRegionFinder

Fields inherited from interface org.apache.hadoop.hbase.master.LoadBalancer

BOGUS_SERVER_NAME, SYSTEM_TABLES_ON_MASTER, TABLES_ON_MASTER

Constructor Summary

Constructors

Constructor and Description
StochasticLoadBalancer() The constructor that pass a MetricsStochasticBalancer to BaseLoadBalancer to replace its default MetricsBalancer
StochasticLoadBalancer(MetricsStochasticBalancer metricsStochasticBalancer)

Method Summary

Modifier and Type	Method and Description
private void	addCostFunction(CostFunction costFunction)
private boolean	areSomeRegionReplicasColocated(BalancerClusterState c)
protected List<RegionPlan>	balanceTable(TableName tableName, Map<ServerName,List<RegionInfo>> loadOfOneTable) Given the cluster state this will try and approach an optimal balance.
private long	calculateMaxSteps(BalancerClusterState cluster)
(package private) static String	composeAttributeName(String tableName, String costFunctionName) A helper function to compose the attribute name from tablename and costfunction name
(package private) double	computeCost(BalancerClusterState cluster, double previousCost) This is the main cost function.
protected List<CandidateGenerator>	createCandidateGenerators()
private static CostFunction	createCostFunction(Class<? extends CostFunction> clazz, org.apache.hadoop.conf.Configuration conf)
private List<RegionPlan>	createRegionPlans(BalancerClusterState cluster) Create all of the RegionPlan's needed to move from the initial cluster state to the desired state.
private String	functionCost()
(package private) List<CandidateGenerator>	getCandidateGenerators()
(package private) String[]	getCostFunctionNames() Get the names of the cost functions
protected CandidateGenerator	getRandomGenerator() Select the candidate generator to use based on the cost of cost functions.
(package private) void	initCosts(BalancerClusterState cluster)
protected void	loadConf(org.apache.hadoop.conf.Configuration conf)
private void	loadCustomCostFunctions(org.apache.hadoop.conf.Configuration conf)
(package private) boolean	needsBalance(TableName tableName, BalancerClusterState cluster)
(package private) BalanceAction	nextAction(BalancerClusterState cluster)
private void	sendRegionPlansToRingBuffer(List<RegionPlan> plans, double currentCost, double initCost, String initFunctionTotalCosts, long step)
private void	sendRejectionReasonToRingBuffer(String reason, List<CostFunction> costFunctions)
(package private) void	setRackManager(RackManager rackManager)
private String	totalCostsPerFunc()
void	updateBalancerLoadInfo(Map<TableName,Map<ServerName,List<RegionInfo>>> loadOfAllTable) In some scenarios, Balancer needs to update internal status or information according to the current tables load
private void	updateBalancerTableLoadInfo(TableName tableName, Map<ServerName,List<RegionInfo>> loadOfOneTable)
void	updateClusterMetrics(ClusterMetrics st) Set the current cluster status.
(package private) void	updateCostsAndWeightsWithAction(BalancerClusterState cluster, BalanceAction action)
(package private) void	updateMetricsSize(int size) Update the number of metrics that are reported to JMX
private void	updateRegionLoad() Store the current region loads.
private void	updateStochasticCosts(TableName tableName, double overall, double[] subCosts) update costs to JMX

Methods inherited from class org.apache.hadoop.hbase.master.balancer.BaseLoadBalancer

assignMasterSystemRegions, balanceCluster, balanceMasterRegions, getConf, getDefaultSlop, idleRegionServerExist, initialize, isStopped, onConfigurationChange, postMasterStartupInitialize, preBalanceCluster, randomAssignment, regionOffline, regionOnline, retainAssignment, roundRobinAssignment, setMasterServices, shouldBeOnMaster, sloppyRegionServerExist, stop, toEnsumbleTableLoad, updateBalancerStatus

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.apache.hadoop.hbase.master.LoadBalancer

isMasterCanHostUserRegions, isSystemTablesOnlyOnMaster, isTablesOnMaster

Field Detail

LOG

private static final org.slf4j.Logger LOG

STEPS_PER_REGION_KEY

protected static final String STEPS_PER_REGION_KEY

See Also:

Constant Field Values

DEFAULT_STEPS_PER_REGION

protected static final int DEFAULT_STEPS_PER_REGION

See Also:

Constant Field Values

MAX_STEPS_KEY

protected static final String MAX_STEPS_KEY

See Also:

Constant Field Values

DEFAULT_MAX_STEPS

protected static final int DEFAULT_MAX_STEPS

See Also:

Constant Field Values

RUN_MAX_STEPS_KEY

protected static final String RUN_MAX_STEPS_KEY

See Also:

Constant Field Values

DEFAULT_RUN_MAX_STEPS

protected static final boolean DEFAULT_RUN_MAX_STEPS

See Also:

Constant Field Values

MAX_RUNNING_TIME_KEY

protected static final String MAX_RUNNING_TIME_KEY

See Also:

Constant Field Values

DEFAULT_MAX_RUNNING_TIME

protected static final long DEFAULT_MAX_RUNNING_TIME

See Also:

Constant Field Values

KEEP_REGION_LOADS

protected static final String KEEP_REGION_LOADS

See Also:

Constant Field Values

DEFAULT_KEEP_REGION_LOADS

protected static final int DEFAULT_KEEP_REGION_LOADS

See Also:

Constant Field Values

TABLE_FUNCTION_SEP

private static final String TABLE_FUNCTION_SEP

See Also:

Constant Field Values

MIN_COST_NEED_BALANCE_KEY

protected static final String MIN_COST_NEED_BALANCE_KEY

See Also:

Constant Field Values

DEFAULT_MIN_COST_NEED_BALANCE

protected static final float DEFAULT_MIN_COST_NEED_BALANCE

See Also:

Constant Field Values

COST_FUNCTIONS_COST_FUNCTIONS_KEY

protected static final String COST_FUNCTIONS_COST_FUNCTIONS_KEY

See Also:

Constant Field Values

OVERALL_COST_FUNCTION_NAME

public static final String OVERALL_COST_FUNCTION_NAME

See Also:

Constant Field Values

loads

Map<String,Deque<BalancerRegionLoad>> loads

maxSteps

private int maxSteps

runMaxSteps

private boolean runMaxSteps

stepsPerRegion

private int stepsPerRegion

maxRunningTime

private long maxRunningTime

numRegionLoadsToRemember

private int numRegionLoadsToRemember

minCostNeedBalance

private float minCostNeedBalance

isBalancerDecisionRecording

private boolean isBalancerDecisionRecording

isBalancerRejectionRecording

private boolean isBalancerRejectionRecording

candidateGenerators

protected List<CandidateGenerator> candidateGenerators

weightsOfGenerators

private double[] weightsOfGenerators

costFunctions

private List<CostFunction> costFunctions

sumMultiplier

private float sumMultiplier

curOverallCost

private double curOverallCost

tempFunctionCosts

private double[] tempFunctionCosts

curFunctionCosts

private double[] curFunctionCosts

localityCandidateGenerator

private LocalityBasedCandidateGenerator localityCandidateGenerator

localityCost

private ServerLocalityCostFunction localityCost

rackLocalityCost

private RackLocalityCostFunction rackLocalityCost

regionReplicaHostCostFunction

private RegionReplicaHostCostFunction regionReplicaHostCostFunction

regionReplicaRackCostFunction

private RegionReplicaRackCostFunction regionReplicaRackCostFunction

namedQueueRecorder

NamedQueueRecorder namedQueueRecorder

Use to add balancer decision history to ring-buffer

Constructor Detail

StochasticLoadBalancer

public StochasticLoadBalancer()

The constructor that pass a MetricsStochasticBalancer to BaseLoadBalancer to replace its default MetricsBalancer

StochasticLoadBalancer

public StochasticLoadBalancer(MetricsStochasticBalancer metricsStochasticBalancer)

Method Detail

createCostFunction

private static CostFunction createCostFunction(Class<? extends CostFunction> clazz,
                                               org.apache.hadoop.conf.Configuration conf)

loadCustomCostFunctions

private void loadCustomCostFunctions(org.apache.hadoop.conf.Configuration conf)

getCandidateGenerators

List<CandidateGenerator> getCandidateGenerators()

createCandidateGenerators

protected List<CandidateGenerator> createCandidateGenerators()

loadConf

protected void loadConf(org.apache.hadoop.conf.Configuration conf)

Overrides:

loadConf in class BaseLoadBalancer

updateClusterMetrics

public void updateClusterMetrics(ClusterMetrics st)

Description copied from interface: LoadBalancer

Set the current cluster status. This allows a LoadBalancer to map host name to a server

Specified by:

updateClusterMetrics in interface LoadBalancer

Overrides:

updateClusterMetrics in class BaseLoadBalancer

updateBalancerTableLoadInfo

private void updateBalancerTableLoadInfo(TableName tableName,
                                         Map<ServerName,List<RegionInfo>> loadOfOneTable)

updateBalancerLoadInfo

public void updateBalancerLoadInfo(Map<TableName,Map<ServerName,List<RegionInfo>>> loadOfAllTable)

Description copied from interface: LoadBalancer

In some scenarios, Balancer needs to update internal status or information according to the current tables load

Parameters:

loadOfAllTable - region load of servers for all table

updateMetricsSize

void updateMetricsSize(int size)

Update the number of metrics that are reported to JMX

areSomeRegionReplicasColocated

private boolean areSomeRegionReplicasColocated(BalancerClusterState c)

needsBalance

boolean needsBalance(TableName tableName,
                     BalancerClusterState cluster)

nextAction

BalanceAction nextAction(BalancerClusterState cluster)

getRandomGenerator

protected CandidateGenerator getRandomGenerator()

Select the candidate generator to use based on the cost of cost functions. The chance of selecting a candidate generator is propotional to the share of cost of all cost functions among all cost functions that benefit from it.

setRackManager

void setRackManager(RackManager rackManager)

calculateMaxSteps

private long calculateMaxSteps(BalancerClusterState cluster)

balanceTable

protected List<RegionPlan> balanceTable(TableName tableName,
                                        Map<ServerName,List<RegionInfo>> loadOfOneTable)

Given the cluster state this will try and approach an optimal balance. This should always approach the optimal state given enough steps.

Specified by:

balanceTable in class BaseLoadBalancer

Parameters:

tableName - the table to be balanced

loadOfOneTable - region load of servers for the specific one table

Returns:

List of plans

sendRejectionReasonToRingBuffer

private void sendRejectionReasonToRingBuffer(String reason,
                                             List<CostFunction> costFunctions)

sendRegionPlansToRingBuffer

private void sendRegionPlansToRingBuffer(List<RegionPlan> plans,
                                         double currentCost,
                                         double initCost,
                                         String initFunctionTotalCosts,
                                         long step)

updateStochasticCosts

private void updateStochasticCosts(TableName tableName,
                                   double overall,
                                   double[] subCosts)

update costs to JMX

addCostFunction

private void addCostFunction(CostFunction costFunction)

functionCost

private String functionCost()

totalCostsPerFunc

private String totalCostsPerFunc()

createRegionPlans

private List<RegionPlan> createRegionPlans(BalancerClusterState cluster)

Create all of the RegionPlan's needed to move from the initial cluster state to the desired state.

Parameters:

cluster - The state of the cluster

Returns:

List of RegionPlan's that represent the moves needed to get to desired final state.

updateRegionLoad

private void updateRegionLoad()

Store the current region loads.

initCosts

void initCosts(BalancerClusterState cluster)

updateCostsAndWeightsWithAction

void updateCostsAndWeightsWithAction(BalancerClusterState cluster,
                                     BalanceAction action)

getCostFunctionNames

String[] getCostFunctionNames()

Get the names of the cost functions

computeCost

double computeCost(BalancerClusterState cluster,
                   double previousCost)

This is the main cost function. It will compute a cost associated with a proposed cluster state. All different costs will be combined with their multipliers to produce a double cost.

Parameters:

cluster - The state of the cluster

previousCost - the previous cost. This is used as an early out.

Returns:

a double of a cost associated with the proposed cluster state. This cost is an aggregate of all individual cost functions.

composeAttributeName

static String composeAttributeName(String tableName,
                                   String costFunctionName)

A helper function to compose the attribute name from tablename and costfunction name