HBASE-26337 Optimization for weighted random generators

Author: clarax

hbase-balancer/src/main/java/org/apache/hadoop/hbase/master/balancer/CostFromRegionLoadFunction.java

@@ -70,6 +70,11 @@ protected final double cost() {
     return cost.cost();
   }
 
+  @Override
+  protected final void updateWeight(double[] weights) {
+    weights[StochasticLoadBalancer.GeneratorType.RANDOM.ordinal()] += cost.cost();
+  }
+
   protected double getRegionLoadCost(Collection<BalancerRegionLoad> regionLoadList) {
     double cost = 0;
     for (BalancerRegionLoad rl : regionLoadList) {
@@ -79,4 +84,4 @@ protected double getRegionLoadCost(Collection<BalancerRegionLoad> regionLoadList
   }
 
   protected abstract double getCostFromRl(BalancerRegionLoad rl);
-}
+}

hbase-balancer/src/main/java/org/apache/hadoop/hbase/master/balancer/CostFunction.java

@@ -83,6 +83,8 @@ protected void regionMoved(int region, int oldServer, int newServer) {
 
   protected abstract double cost();
 
+  protected abstract void updateWeight(double[] weights);
+
   /**
    * Scale the value between 0 and 1.
    * @param min Min value

hbase-balancer/src/main/java/org/apache/hadoop/hbase/master/balancer/LocalityBasedCostFunction.java

@@ -88,4 +88,8 @@ private double getWeightedLocality(int region, int entity) {
     return cluster.getOrComputeWeightedLocality(region, entity, type);
   }
 
-}
+  @Override
+  protected final void updateWeight(double[] weights) {
+    weights[StochasticLoadBalancer.GeneratorType.LOCALITY.ordinal()] += cost();
+  }
+}

hbase-balancer/src/main/java/org/apache/hadoop/hbase/master/balancer/RegionCountSkewCostFunction.java

@@ -72,4 +72,9 @@ protected void regionMoved(int region, int oldServer, int newServer) {
       costs[newServer] = cluster.regionsPerServer[newServer].length;
     });
   }
-}
+
+  @Override
+  protected final void updateWeight(double[] weights) {
+    weights[StochasticLoadBalancer.GeneratorType.LOAD.ordinal()] += cost.cost();
+  }
+}

hbase-balancer/src/main/java/org/apache/hadoop/hbase/master/balancer/RegionReplicaGroupingCostFunction.java

@@ -74,6 +74,11 @@ protected double cost() {
     return scale(0, maxCost, totalCost);
   }
 
+  @Override
+  protected final void updateWeight(double[] weights) {
+    weights[StochasticLoadBalancer.GeneratorType.RACK.ordinal()] += cost();
+  }
+
   /**
    * For each primary region, it computes the total number of replicas in the array (numReplicas)
    * and returns a sum of numReplicas-1 squared. For example, if the server hosts regions a, b, c,

hbase-balancer/src/main/java/org/apache/hadoop/hbase/master/balancer/StochasticLoadBalancer.java

@@ -137,6 +137,7 @@ public class StochasticLoadBalancer extends BaseLoadBalancer {
   private double curOverallCost = 0d;
   private double[] tempFunctionCosts;
   private double[] curFunctionCosts;
+  private double[] weightOfGenerator;
 
   // Keep locality based picker and cost function to alert them
   // when new services are offered
@@ -146,6 +147,10 @@ public class StochasticLoadBalancer extends BaseLoadBalancer {
   private RegionReplicaHostCostFunction regionReplicaHostCostFunction;
   private RegionReplicaRackCostFunction regionReplicaRackCostFunction;
 
+  public enum GeneratorType {
+    RANDOM, LOAD, LOCALITY, RACK,
+  }
+
   /**
    * The constructor that pass a MetricsStochasticBalancer to BaseLoadBalancer to replace its
    * default MetricsBalancer
@@ -204,10 +209,11 @@ protected float getDefaultSlop() {
 
   protected List<CandidateGenerator> createCandidateGenerators() {
     List<CandidateGenerator> candidateGenerators = new ArrayList<CandidateGenerator>(4);
-    candidateGenerators.add(new RandomCandidateGenerator());
-    candidateGenerators.add(new LoadCandidateGenerator());
-    candidateGenerators.add(localityCandidateGenerator);
-    candidateGenerators.add(new RegionReplicaRackCandidateGenerator());
+    candidateGenerators.add(GeneratorType.RANDOM.ordinal(), new RandomCandidateGenerator());
+    candidateGenerators.add(GeneratorType.LOAD.ordinal(), new LoadCandidateGenerator());
+    candidateGenerators.add(GeneratorType.LOCALITY.ordinal(), localityCandidateGenerator);
+    candidateGenerators.add(GeneratorType.RACK.ordinal(),
+      new RegionReplicaRackCandidateGenerator());
     return candidateGenerators;
   }
 
@@ -393,6 +399,27 @@ BalanceAction nextAction(BalancerClusterState cluster) {
       .generate(cluster);
   }
 
+  private CandidateGenerator getRandomGenerate() {
+    double sum = 0;
+    for (int i = 0; i < weightOfGenerator.length; i++) {
+      sum += weightOfGenerator[i];
+      weightOfGenerator[i] = sum;
+    }
+    if (sum == 0) {
+      return candidateGenerators.get(0);
+    }
+    for (int i = 0; i < weightOfGenerator.length; i++) {
+      weightOfGenerator[i] /= sum;
+    }
+    double rand = ThreadLocalRandom.current().nextDouble();
+    for (int i = 0; i < weightOfGenerator.length; i++) {
+      if (rand <= weightOfGenerator[i]) {
+        return candidateGenerators.get(i);
+      }
+    }
+    return candidateGenerators.get(candidateGenerators.size() - 1);
+  }
+
   @RestrictedApi(explanation = "Should only be called in tests", link = "",
     allowedOnPath = ".*/src/test/.*")
   void setRackManager(RackManager rackManager) {
@@ -476,6 +503,8 @@ protected List<RegionPlan> balanceTable(TableName tableName, Map<ServerName,
     long step;
 
     for (step = 0; step < computedMaxSteps; step++) {
+      // Initialize the weights of generator every time
+      weightOfGenerator = new double[this.candidateGenerators.size()];
       BalanceAction action = nextAction(cluster);
 
       if (action.getType() == BalanceAction.Type.NULL) {