implemented static stride scheduler class/algorithm (currently unused)

go/static-stride-scheduler

Author: tonyjongyoonan

xds/src/main/java/io/grpc/xds/WeightedRoundRobinLoadBalancer.java

@@ -310,6 +310,37 @@ private void updateWeight() {
       }
       this.scheduler = scheduler;
     }
+    
+    // check correctness of behavior
+    private void updateWeightSSS() {
+      int weightedChannelCount = 0;
+      double avgWeight = 0;
+      for (Subchannel value : list) {
+        double newWeight = ((WrrSubchannel) value).getWeight();
+        if (newWeight > 0) {
+          avgWeight += newWeight;
+          weightedChannelCount++;
+        }
+      }
+
+      if (weightedChannelCount >= 1) {
+        avgWeight /= 1.0 * weightedChannelCount;
+      } else {
+        avgWeight = 1;
+      }
+
+      List<Float> newWeights = new ArrayList<>();
+      for (int i = 0; i < list.size(); i++) {
+        WrrSubchannel subchannel = (WrrSubchannel) list.get(i);
+        double newWeight = subchannel.getWeight();
+        newWeights.add(
+            i,
+            newWeight > 0 ? (float) newWeight : (float) avgWeight); // check desired type (float?)
+      }
+
+      StaticStrideScheduler ssScheduler = new StaticStrideScheduler(newWeights);
+      this.ssScheduler = ssScheduler;
+    }
 
     @Override
     public String toString() {
@@ -432,6 +463,83 @@ int pick() {
     }
   }
 
+  // TODO: add javadocs comments
+  @VisibleForTesting
+  static final class StaticStrideScheduler {
+    private Vector<Long> scaledWeights;
+    private int sizeDivisor;
+    private long sequence;
+    private static final int K_MAX_WEIGHT = 65535; // uint16? can be uint8
+    private static final long UINT32_MAX = 429967295L; // max value for uint32
+
+    StaticStrideScheduler(List<Float> weights) {
+      int numChannels = weights.size();
+      int numZeroWeightChannels = 0;
+      double sumWeight = 0;
+      float maxWeight = 0;
+      for (float weight : weights) {
+        if (weight == 0) {
+          numZeroWeightChannels++;
+        }
+        sumWeight += weight;
+        maxWeight = Math.max(weight, maxWeight);
+      }
+
+      // checkArgument(numChannels <= 1, "Couldn't build scheduler: requires at least two weights");
+      // checkArgument(numZeroWeightChannels == numChannels, "Couldn't build scheduler: only zero
+      // weights");
+
+      double scalingFactor = K_MAX_WEIGHT / maxWeight;
+      long meanWeight =
+          Math.round(scalingFactor * sumWeight / (numChannels - numZeroWeightChannels));
+
+      // scales weights s.t. max(weights) == K_MAX_WEIGHT, meanWeight is scaled accordingly
+      Vector<Long> scaledWeights = new Vector<>(numChannels);
+      // vectors are deprecated post Java 9?
+      for (int i = 0; i < numChannels; i++) {
+        if (weights.get(i) == 0) {
+          scaledWeights.add(meanWeight);
+        } else {
+          scaledWeights.add(Math.round(weights.get(i) * scalingFactor));
+        }
+      }
+
+      this.scaledWeights = scaledWeights;
+      this.sizeDivisor = numChannels; // why not just call it numChannels or numBackends
+      this.sequence = (long) (Math.random() * UINT32_MAX); // why not initialize to [0,numChannels)
+    }
+
+    private long nextSequence() {
+      long sequence = this.sequence;
+      this.sequence = (this.sequence + 1) % UINT32_MAX; // check wraparound logic
+      return sequence;
+    }
+
+    // is this getter necessary? (is it ever called outside of this class)
+    public Vector<Long> getWeights() {
+      return this.scaledWeights;
+    }
+
+    private void addChannel() {}
+
+    // selects index of our next backend server
+    int pickChannel() {
+      while (true) {
+        long sequence = this.nextSequence();
+        int backendIndex = (int) sequence % this.sizeDivisor;
+        long generation = sequence / this.sizeDivisor;
+        // is this really that much more efficient than a 2d array?
+        long weight = this.scaledWeights.get(backendIndex);
+        long kOffset = K_MAX_WEIGHT / 2;
+        long mod = (weight * generation + backendIndex * kOffset) % K_MAX_WEIGHT;
+        if (mod < K_MAX_WEIGHT - weight) { // review this math
+          continue;
+        }
+        return backendIndex;
+      }
+    }
+  }
+
   /** Holds the state of the object. */
   @VisibleForTesting
   static class ObjectState {