BaseLoadBalancer.Cluster (Apache HBase 2.0.6 API)

java.lang.Object
- org.apache.hadoop.hbase.master.balancer.BaseLoadBalancer.Cluster

Enclosing class:

BaseLoadBalancer
```
protected static class BaseLoadBalancer.Cluster
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. Cluster 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
`static class`	`BaseLoadBalancer.Cluster.Action` An action to move or swap a region
`static class`	`BaseLoadBalancer.Cluster.AssignRegionAction`
`(package private) static class`	`BaseLoadBalancer.Cluster.LocalityType`
`static class`	`BaseLoadBalancer.Cluster.MoveRegionAction`
`static class`	`BaseLoadBalancer.Cluster.SwapRegionsAction`

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) Map<ServerName,List<RegionInfo>>`	`clusterState`
`(package private) boolean`	`hasRegionReplicas`
`(package private) String[]`	`hosts`
`(package private) Map<String,Integer>`	`hostsToIndex`
`(package private) int[]`	`initialRegionIndexToServerIndex`
`(package private) float[]`	`localityPerServer`
`(package private) boolean`	`multiServersPerHost`
`static BaseLoadBalancer.Cluster.Action`	`NullAction`
`(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`	`numServers`
`(package private) int`	`numTables`
`(package private) int[][]`	`primariesOfRegionsPerHost`
`(package private) int[][]`	`primariesOfRegionsPerRack`
`(package private) int[][]`	`primariesOfRegionsPerServer`
`private float[][]`	`rackLocalities`
`protected 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) Integer[]`	`serverIndicesSortedByLocality`
`(package private) Integer[]`	`serverIndicesSortedByRegionCount`
`(package private) ServerName[]`	`servers`
`(package private) int[][]`	`serversPerHost`
`(package private) int[][]`	`serversPerRack`
`(package private) Map<String,Integer>`	`serversToIndex`
`(package private) ArrayList<String>`	`tables`
`(package private) Map<String,Integer>`	`tablesToIndex`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Cluster(Collection<RegionInfo> unassignedRegions, Map<ServerName,List<RegionInfo>> clusterState, Map<String,Deque<BalancerRegionLoad>> loads, RegionLocationFinder regionFinder, RackManager rackManager)`
`protected`	`Cluster(Map<ServerName,List<RegionInfo>> clusterState, Map<String,Deque<BalancerRegionLoad>> loads, RegionLocationFinder regionFinder, RackManager rackManager)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) int[]`	`addRegion(int[] regions, int regionIndex)`
`(package private) int[]`	`addRegionSorted(int[] regions, int regionIndex)`
`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(BaseLoadBalancer.Cluster.Action 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)`
`float`	`getOrComputeLocality(int region, int entity, BaseLoadBalancer.Cluster.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(BaseLoadBalancer.Cluster.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, BaseLoadBalancer.Cluster.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
`(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
`protected void`	`setNumMovedRegions(int numMovedRegions)`
`protected void`	`setNumRegions(int numRegions)`
`(package private) void`	`sortServersByRegionCount()`
`String`	`toString()`
`(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

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
```

regionsPerHost
```
int[][] regionsPerHost
```

regionsPerRack
```
int[][] regionsPerRack
```

primariesOfRegionsPerServer
```
int[][] primariesOfRegionsPerServer
```

primariesOfRegionsPerHost
```
int[][] primariesOfRegionsPerHost
```

primariesOfRegionsPerRack
```
int[][] primariesOfRegionsPerRack
```

serversPerHost
```
int[][] serversPerHost
```

serversPerRack
```
int[][] serversPerRack
```

regionIndexToServerIndex
```
int[] regionIndexToServerIndex
```

initialRegionIndexToServerIndex
```
int[] initialRegionIndexToServerIndex
```

regionIndexToTableIndex
```
int[] regionIndexToTableIndex
```

numRegionsPerServerPerTable
```
int[][] numRegionsPerServerPerTable
```

numMaxRegionsPerTable
```
int[] numMaxRegionsPerTable
```

regionIndexToPrimaryIndex
```
int[] regionIndexToPrimaryIndex
```

hasRegionReplicas
```
boolean hasRegionReplicas
```

serverIndicesSortedByRegionCount

Integer[] serverIndicesSortedByRegionCount

serverIndicesSortedByLocality
```
Integer[] serverIndicesSortedByLocality
```

serversToIndex
```
Map<String,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

protected final RackManager rackManager

rackLocalities
```
private float[][] rackLocalities
```

regionsToMostLocalEntities

private int[][] regionsToMostLocalEntities

NullAction

public static final BaseLoadBalancer.Cluster.Action NullAction

numRegionsComparator

private Comparator<Integer> numRegionsComparator

Constructor Detail

Cluster

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

Cluster

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

Method Detail

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(BaseLoadBalancer.Cluster.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,
                                  BaseLoadBalancer.Cluster.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,
                                           BaseLoadBalancer.Cluster.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(BaseLoadBalancer.Cluster.Action 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

doAssignRegion

void doAssignRegion(RegionInfo regionInfo,
                    ServerName serverName)

regionMoved

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

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)
```

contains

boolean contains(int[] arr,
                 int val)

getLowestLocalityRegionOnServer

int getLowestLocalityRegionOnServer(int serverIndex)

getLocalityOfRegion

float getLocalityOfRegion(int region,
                          int server)

setNumRegions

protected void setNumRegions(int numRegions)

setNumMovedRegions

protected void setNumMovedRegions(int numMovedRegions)

toString
```
public String toString()
```
Overrides:

toString in class Object

Class BaseLoadBalancer.Cluster

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

servers

hosts

racks

multiServersPerHost

tables

regions

regionLoads

regionFinder

regionLocations

serverIndexToHostIndex

serverIndexToRackIndex

regionsPerServer

regionsPerHost

regionsPerRack

primariesOfRegionsPerServer

primariesOfRegionsPerHost

primariesOfRegionsPerRack

serversPerHost

serversPerRack

regionIndexToServerIndex

initialRegionIndexToServerIndex

regionIndexToTableIndex

numRegionsPerServerPerTable

numMaxRegionsPerTable

regionIndexToPrimaryIndex

hasRegionReplicas

serverIndicesSortedByRegionCount

serverIndicesSortedByLocality

serversToIndex

hostsToIndex

racksToIndex

tablesToIndex

regionsToIndex

localityPerServer

numServers

numHosts

numRacks

numTables

numRegions

numMovedRegions

clusterState

rackManager

rackLocalities

regionsToMostLocalEntities

NullAction

numRegionsComparator

Constructor Detail

Cluster

Cluster

Method Detail

registerRegion

serverHasTooFewRegions

getOrComputeRackLocalities

getOrComputeRegionsToMostLocalEntities

getOrComputeLocality

getOrComputeWeightedLocality

getRegionSizeMB

computeCachedLocalities

getRackForRegion

doAction

wouldLowerAvailability

doAssignRegion

regionMoved

removeRegion

addRegion

addRegionSorted

replaceRegion

sortServersByRegionCount

getNumRegions

contains

getLowestLocalityRegionOnServer

getLocalityOfRegion

setNumRegions