org.apache.hadoop.hbase.master.balancer

Class BalancerClusterState

java.lang.Object

org.apache.hadoop.hbase.master.balancer.BalancerClusterState

@InterfaceAudience.Private
class BalancerClusterState
extends Object

An efficient array based implementation similar to ClusterState for keeping the status of the cluster in terms of region assignment and distribution. LoadBalancers, such as StochasticLoadBalancer uses this Cluster object because of hundreds of thousands of hashmap manipulations are very costly, which is why this class uses mostly indexes and arrays.

BalancerClusterState tracks a list of unassigned regions, region assignments, and the server topology in terms of server names, hostnames and racks.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
(package private) static class	BalancerClusterState.DefaultRackManager
(package private) static class	BalancerClusterState.LocalityType

Field Summary

Fields

Modifier and Type	Field and Description
(package private) Map<ServerName,List<RegionInfo>>	clusterState
(package private) org.agrona.collections.Int2IntCounterMap[]	colocatedReplicaCountsPerHost
(package private) org.agrona.collections.Int2IntCounterMap[]	colocatedReplicaCountsPerRack
(package private) org.agrona.collections.Int2IntCounterMap[]	colocatedReplicaCountsPerServer
(package private) boolean	hasRegionReplicas
(package private) String[]	hosts
(package private) Map<String,Integer>	hostsToIndex
(package private) int[]	initialRegionIndexToServerIndex
(package private) float[]	localityPerServer
private static org.slf4j.Logger	LOG
(package private) boolean	multiServersPerHost
(package private) int	numHosts
(package private) int[]	numMaxRegionsPerTable
(package private) int	numMovedRegions
(package private) int	numRacks
(package private) int	numRegions
private Comparator<Integer>	numRegionsComparator
(package private) int[][]	numRegionsPerServerPerTable
(package private) int[]	numRegionsPerTable
(package private) int	numServers
(package private) int	numTables
private float[][]	rackLocalities
private RackManager	rackManager
(package private) String[]	racks
(package private) Map<String,Integer>	racksToIndex
private RegionLocationFinder	regionFinder
(package private) int[]	regionIndexToPrimaryIndex
(package private) int[]	regionIndexToServerIndex
(package private) int[]	regionIndexToTableIndex
(package private) Deque<BalancerRegionLoad>[]	regionLoads
(package private) int[][]	regionLocations
(package private) RegionInfo[]	regions
(package private) int[][]	regionsPerHost
(package private) int[][]	regionsPerRack
(package private) int[][]	regionsPerServer
(package private) Map<RegionInfo,Integer>	regionsToIndex
private int[][]	regionsToMostLocalEntities
(package private) int[]	serverIndexToHostIndex
(package private) int[]	serverIndexToRackIndex
(package private) int[]	serverIndexToRegionsOffset
(package private) Integer[]	serverIndicesSortedByLocality
(package private) Integer[]	serverIndicesSortedByRegionCount
(package private) ServerName[]	servers
(package private) int[][]	serversPerHost
(package private) int[][]	serversPerRack
(package private) Map<Address,Integer>	serversToIndex
(package private) ArrayList<String>	tables
(package private) Map<String,Integer>	tablesToIndex

Constructor Summary

Constructors

Constructor and Description
BalancerClusterState(Collection<RegionInfo> unassignedRegions, Map<ServerName,List<RegionInfo>> clusterState, Map<String,Deque<BalancerRegionLoad>> loads, RegionLocationFinder regionFinder, RackManager rackManager)
BalancerClusterState(Map<ServerName,List<RegionInfo>> clusterState, Map<String,Deque<BalancerRegionLoad>> loads, RegionLocationFinder regionFinder, RackManager rackManager)

Method Summary

Modifier and Type	Method and Description
(package private) int[]	addRegion(int[] regions, int regionIndex)
(package private) int[]	addRegionSorted(int[] regions, int regionIndex)
private int	checkLocationForPrimary(int location, org.agrona.collections.Int2IntCounterMap[] colocatedReplicaCountsPerLocation, int primary) Common method for better solution check.
private void	computeCachedLocalities() Computes and caches the locality for each region/rack combinations, as well as storing a mapping of region -> server and region -> rack such that server and rack have the highest locality for region
(package private) boolean	contains(int[] arr, int val)
void	doAction(BalanceAction action)
(package private) void	doAssignRegion(RegionInfo regionInfo, ServerName serverName)
(package private) float	getLocalityOfRegion(int region, int server)
(package private) int	getLowestLocalityRegionOnServer(int serverIndex)
(package private) int	getNumRegions(int server)
Comparator<Integer>	getNumRegionsComparator()
float	getOrComputeLocality(int region, int entity, BalancerClusterState.LocalityType type) Looks up locality from cache of localities.
float[][]	getOrComputeRackLocalities() Retrieves and lazily initializes a field storing the locality of every region/server combination
int[]	getOrComputeRegionsToMostLocalEntities(BalancerClusterState.LocalityType type) Lazily initializes and retrieves a mapping of region -> server for which region has the highest the locality
double	getOrComputeWeightedLocality(int region, int server, BalancerClusterState.LocalityType type) Returns locality weighted by region size in MB.
int	getRackForRegion(int region) Maps region index to rack index
int	getRegionSizeMB(int region) Returns the size in MB from the most recent RegionLoad for region
private void	populateRegionPerLocationFromServer(int[][] regionsPerLocation, org.agrona.collections.Int2IntCounterMap[] colocatedReplicaCountsPerLocation, int[][] serversPerLocation)
(package private) void	regionMoved(int region, int oldServer, int newServer)
private void	registerRegion(RegionInfo region, int regionIndex, int serverIndex, Map<String,Deque<BalancerRegionLoad>> loads, RegionLocationFinder regionFinder) Helper for Cluster constructor to handle a region
(package private) int[]	removeRegion(int[] regions, int regionIndex)
(package private) int[]	replaceRegion(int[] regions, int regionIndex, int newRegionIndex)
boolean	serverHasTooFewRegions(int server) Returns true iff a given server has less regions than the balanced amount
(package private) void	setNumMovedRegions(int numMovedRegions)
(package private) void	setNumRegions(int numRegions)
(package private) void	sortServersByRegionCount()
String	toString()
private void	updateForLocation(int[] serverIndexToLocation, int[][] regionsPerLocation, org.agrona.collections.Int2IntCounterMap[] colocatedReplicaCountsPerLocation, int oldServer, int newServer, int primary, int region) Common method for per host and per Location region index updates when a region is moved.
(package private) boolean	wouldLowerAvailability(RegionInfo regionInfo, ServerName serverName) Return true if the placement of region on server would lower the availability of the region in question

Methods inherited from class java.lang.Object

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

Field Detail

LOG

private static final org.slf4j.Logger LOG

servers

ServerName[] servers

hosts

String[] hosts

racks

String[] racks

multiServersPerHost

boolean multiServersPerHost

tables

ArrayList<String> tables

regions

RegionInfo[] regions

regionLoads

Deque<BalancerRegionLoad>[] regionLoads

regionFinder

private RegionLocationFinder regionFinder

regionLocations

int[][] regionLocations

serverIndexToHostIndex

int[] serverIndexToHostIndex

serverIndexToRackIndex

int[] serverIndexToRackIndex

regionsPerServer

int[][] regionsPerServer

serverIndexToRegionsOffset

int[] serverIndexToRegionsOffset

regionsPerHost

int[][] regionsPerHost

regionsPerRack

int[][] regionsPerRack

colocatedReplicaCountsPerServer

org.agrona.collections.Int2IntCounterMap[] colocatedReplicaCountsPerServer

colocatedReplicaCountsPerHost

org.agrona.collections.Int2IntCounterMap[] colocatedReplicaCountsPerHost

colocatedReplicaCountsPerRack

org.agrona.collections.Int2IntCounterMap[] colocatedReplicaCountsPerRack

serversPerHost

int[][] serversPerHost

serversPerRack

int[][] serversPerRack

regionIndexToServerIndex

int[] regionIndexToServerIndex

initialRegionIndexToServerIndex

int[] initialRegionIndexToServerIndex

regionIndexToTableIndex

int[] regionIndexToTableIndex

numRegionsPerServerPerTable

int[][] numRegionsPerServerPerTable

numRegionsPerTable

int[] numRegionsPerTable

numMaxRegionsPerTable

int[] numMaxRegionsPerTable

regionIndexToPrimaryIndex

int[] regionIndexToPrimaryIndex

hasRegionReplicas

boolean hasRegionReplicas

serverIndicesSortedByRegionCount

Integer[] serverIndicesSortedByRegionCount

serverIndicesSortedByLocality

Integer[] serverIndicesSortedByLocality

serversToIndex

Map<Address,Integer> serversToIndex

hostsToIndex

Map<String,Integer> hostsToIndex

racksToIndex

Map<String,Integer> racksToIndex

tablesToIndex

Map<String,Integer> tablesToIndex

regionsToIndex

Map<RegionInfo,Integer> regionsToIndex

localityPerServer

float[] localityPerServer

numServers

int numServers

numHosts

int numHosts

numRacks

int numRacks

numTables

int numTables

numRegions

int numRegions

numMovedRegions

int numMovedRegions

clusterState

Map<ServerName,List<RegionInfo>> clusterState

rackManager

private final RackManager rackManager

rackLocalities

private float[][] rackLocalities

regionsToMostLocalEntities

private int[][] regionsToMostLocalEntities

numRegionsComparator

private Comparator<Integer> numRegionsComparator

Constructor Detail

BalancerClusterState

BalancerClusterState(Map<ServerName,List<RegionInfo>> clusterState,
                     Map<String,Deque<BalancerRegionLoad>> loads,
                     RegionLocationFinder regionFinder,
                     RackManager rackManager)

BalancerClusterState

BalancerClusterState(Collection<RegionInfo> unassignedRegions,
                     Map<ServerName,List<RegionInfo>> clusterState,
                     Map<String,Deque<BalancerRegionLoad>> loads,
                     RegionLocationFinder regionFinder,
                     RackManager rackManager)

Method Detail

populateRegionPerLocationFromServer

private void populateRegionPerLocationFromServer(int[][] regionsPerLocation,
                                                 org.agrona.collections.Int2IntCounterMap[] colocatedReplicaCountsPerLocation,
                                                 int[][] serversPerLocation)

registerRegion

private void registerRegion(RegionInfo region,
                            int regionIndex,
                            int serverIndex,
                            Map<String,Deque<BalancerRegionLoad>> loads,
                            RegionLocationFinder regionFinder)

Helper for Cluster constructor to handle a region

serverHasTooFewRegions

public boolean serverHasTooFewRegions(int server)

Returns true iff a given server has less regions than the balanced amount

getOrComputeRackLocalities

public float[][] getOrComputeRackLocalities()

Retrieves and lazily initializes a field storing the locality of every region/server combination

getOrComputeRegionsToMostLocalEntities

public int[] getOrComputeRegionsToMostLocalEntities(BalancerClusterState.LocalityType type)

Lazily initializes and retrieves a mapping of region -> server for which region has the highest the locality

getOrComputeLocality

public float getOrComputeLocality(int region,
                                  int entity,
                                  BalancerClusterState.LocalityType type)

Looks up locality from cache of localities. Will create cache if it does not already exist.

getOrComputeWeightedLocality

public double getOrComputeWeightedLocality(int region,
                                           int server,
                                           BalancerClusterState.LocalityType type)

Returns locality weighted by region size in MB. Will create locality cache if it does not already exist.

getRegionSizeMB

public int getRegionSizeMB(int region)

Returns the size in MB from the most recent RegionLoad for region

computeCachedLocalities

private void computeCachedLocalities()

Computes and caches the locality for each region/rack combinations, as well as storing a mapping of region -> server and region -> rack such that server and rack have the highest locality for region

getRackForRegion

public int getRackForRegion(int region)

Maps region index to rack index

doAction

public void doAction(BalanceAction action)

wouldLowerAvailability

boolean wouldLowerAvailability(RegionInfo regionInfo,
                               ServerName serverName)

Return true if the placement of region on server would lower the availability of the region in question

Returns:

true or false

checkLocationForPrimary

private int checkLocationForPrimary(int location,
                                    org.agrona.collections.Int2IntCounterMap[] colocatedReplicaCountsPerLocation,
                                    int primary)

Common method for better solution check.

Parameters:

colocatedReplicaCountsPerLocation - colocatedReplicaCountsPerHost or colocatedReplicaCountsPerRack

Returns:

1 for better, -1 for no better, 0 for unknown

doAssignRegion

void doAssignRegion(RegionInfo regionInfo,
                    ServerName serverName)

regionMoved

void regionMoved(int region,
                 int oldServer,
                 int newServer)

updateForLocation

private void updateForLocation(int[] serverIndexToLocation,
                               int[][] regionsPerLocation,
                               org.agrona.collections.Int2IntCounterMap[] colocatedReplicaCountsPerLocation,
                               int oldServer,
                               int newServer,
                               int primary,
                               int region)

Common method for per host and per Location region index updates when a region is moved.

Parameters:

serverIndexToLocation - serverIndexToHostIndex or serverIndexToLocationIndex

regionsPerLocation - regionsPerHost or regionsPerLocation

colocatedReplicaCountsPerLocation - colocatedReplicaCountsPerHost or colocatedReplicaCountsPerRack

removeRegion

int[] removeRegion(int[] regions,
                   int regionIndex)

addRegion

int[] addRegion(int[] regions,
                int regionIndex)

addRegionSorted

int[] addRegionSorted(int[] regions,
                      int regionIndex)

replaceRegion

int[] replaceRegion(int[] regions,
                    int regionIndex,
                    int newRegionIndex)

sortServersByRegionCount

void sortServersByRegionCount()

getNumRegions

int getNumRegions(int server)

getNumRegionsComparator

public Comparator<Integer> getNumRegionsComparator()

contains

boolean contains(int[] arr,
                 int val)

getLowestLocalityRegionOnServer

int getLowestLocalityRegionOnServer(int serverIndex)

getLocalityOfRegion

float getLocalityOfRegion(int region,
                          int server)

setNumRegions

void setNumRegions(int numRegions)

setNumMovedRegions

void setNumMovedRegions(int numMovedRegions)

toString

public String toString()

Overrides:

toString in class Object