Add support for more instances than keys

theodolite-benchmarks/load-generator-commons/src/main/java/rocks/theodolite/benchmarks/loadgenerator/KeySpace.java

@@ -10,7 +10,7 @@ import java.util.stream.IntStream;
  */
 public class KeySpace implements Serializable {
 
-  private static final long serialVersionUID = 7343135392720315515L; // NOPMD
+  private static final long serialVersionUID = 7343135392720315516L; // NOPMD
 
   private final String prefix;
   private final int min;
@@ -18,11 +18,11 @@ public class KeySpace implements Serializable {
 
   /**
    * Create a new key space. All keys will have the prefix {@code prefix}. The remaining part of
-   * each key will be determined by a number of the interval ({@code min}, {@code max}).
+   * each key will be determined by a number of the interval [{@code min}, {@code max}).
    *
    * @param prefix the prefix to use for all keys
    * @param min the lower bound (inclusive) to start counting from
-   * @param max the upper bound (inclusive) to count to
+   * @param max the upper bound (exclusive) to count to
    */
   public KeySpace(final String prefix, final int min, final int max) {
     this.prefix = prefix;
@@ -31,7 +31,7 @@ public class KeySpace implements Serializable {
   }
 
   public KeySpace(final String prefix, final int numberOfKeys) {
-    this(prefix, 0, numberOfKeys - 1);
+    this(prefix, 0, numberOfKeys);
   }
 
   public String getPrefix() {
@@ -52,21 +52,21 @@ public class KeySpace implements Serializable {
    * Get the amount of keys in this {@link KeySpace}.
    */
   public int getCount() {
-    return this.getMax() - this.getMin() + 1;
+    return this.max - this.min;
   }
 
   /**
    * Get all keys in this {@link KeySpace}.
    */
   public Collection<String> getKeys() {
-    return IntStream.rangeClosed(this.min, this.max)
+    return IntStream.range(this.min, this.max)
         .mapToObj(id -> this.prefix + id)
         .collect(Collectors.toUnmodifiableList());
   }
 
   @Override
   public String toString() {
-    return this.prefix + '[' + this.min + '-' + this.max + ']';
+    return this.prefix + '[' + this.min + '-' + this.max + ')';
   }
 
 }

theodolite-benchmarks/load-generator-commons/src/main/java/rocks/theodolite/benchmarks/loadgenerator/WorkloadDefinition.java

@@ -42,16 +42,16 @@ public class WorkloadDefinition implements Serializable {
    * distributing its {@link KeySpace} (almost) equally among all {@link WorkloadDefinition}s.
    */
   public Set<WorkloadDefinition> divide(final int parts) {
-    final int effParts = Math.min(parts, this.keySpace.getCount());
-    final int minSize = this.keySpace.getCount() / effParts;
-    final int largerParts = this.keySpace.getCount() % effParts;
-    return IntStream.range(0, effParts)
+    // final int effParts = Math.min(parts, this.keySpace.getCount());
+    final int minSize = this.keySpace.getCount() / parts;
+    final int largerParts = this.keySpace.getCount() % parts;
+    return IntStream.range(0, parts)
         .mapToObj(part -> {
           final int thisSize = part < largerParts ? minSize + 1 : minSize;
           final int largePartsBefore = Math.min(largerParts, part);
           final int smallPartsBefore = part - largePartsBefore;
           final int start = largePartsBefore * (minSize + 1) + smallPartsBefore * minSize;
-          final int end = start + thisSize - 1;
+          final int end = start + thisSize;
           return new KeySpace(
               this.keySpace.getPrefix(),
               start,

theodolite-benchmarks/load-generator-commons/src/test/java/rocks/theodolite/benchmarks/loadgenerator/KeySpaceTest.java

@@ -7,14 +7,14 @@ public class KeySpaceTest {
 
   @Test
   public void testCountFixedRangeFromZero() {
-    final KeySpace keySpace = new KeySpace("prefix", 0, 9);
+    final KeySpace keySpace = new KeySpace("prefix", 0, 10);
     final int count = keySpace.getCount();
     Assert.assertEquals(10, count);
   }
 
   @Test
   public void testCountFixedRangeNotFromZero() {
-    final KeySpace keySpace = new KeySpace("prefix", 4, 11);
+    final KeySpace keySpace = new KeySpace("prefix", 4, 12);
     final int count = keySpace.getCount();
     Assert.assertEquals(8, count);
   }

theodolite-benchmarks/load-generator-commons/src/test/java/rocks/theodolite/benchmarks/loadgenerator/WorkloadDefinitionTest.java

@@ -5,6 +5,7 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -47,15 +48,27 @@ public class WorkloadDefinitionTest {
     final List<WorkloadDefinition> orderedSubworkloads = subworkloads.stream()
         .sorted(Comparator.comparingInt(l -> l.getKeySpace().getMin()))
         .collect(Collectors.toList());
+
     final WorkloadDefinition subworkload1 = orderedSubworkloads.get(0);
-    Assert.assertEquals(0, subworkload1.getKeySpace().getMin());
-    Assert.assertEquals(33, subworkload1.getKeySpace().getMax());
+    final List<String> expectedKeySubworkload1 = IntStream
+        .rangeClosed(0, 33)
+        .mapToObj(id -> "prefix" + id)
+        .collect(Collectors.toList());
+    Assert.assertEquals(expectedKeySubworkload1, subworkload1.getKeySpace().getKeys());
+
     final WorkloadDefinition subworkload2 = orderedSubworkloads.get(1);
-    Assert.assertEquals(34, subworkload2.getKeySpace().getMin());
-    Assert.assertEquals(66, subworkload2.getKeySpace().getMax());
+    final List<String> expectedKeySubworkload2 = IntStream
+        .rangeClosed(34, 66)
+        .mapToObj(id -> "prefix" + id)
+        .collect(Collectors.toList());
+    Assert.assertEquals(expectedKeySubworkload2, subworkload2.getKeySpace().getKeys());
+
     final WorkloadDefinition subworkload3 = orderedSubworkloads.get(2);
-    Assert.assertEquals(67, subworkload3.getKeySpace().getMin());
-    Assert.assertEquals(99, subworkload3.getKeySpace().getMax());
+    final List<String> expectedKeySubworkload3 = IntStream
+        .rangeClosed(67, 99)
+        .mapToObj(id -> "prefix" + id)
+        .collect(Collectors.toList());
+    Assert.assertEquals(expectedKeySubworkload3, subworkload3.getKeySpace().getKeys());
   }
 
   @Test
@@ -71,27 +84,109 @@ public class WorkloadDefinitionTest {
     final List<WorkloadDefinition> orderedSubworkloads = subworkloads.stream()
         .sorted(Comparator.comparingInt(l -> l.getKeySpace().getMin()))
         .collect(Collectors.toList());
+
     final WorkloadDefinition subworkload1 = orderedSubworkloads.get(0);
-    Assert.assertEquals(0, subworkload1.getKeySpace().getMin());
-    Assert.assertEquals(1, subworkload1.getKeySpace().getMax());
+    final List<String> expectedKeySubworkload1 = IntStream
+        .rangeClosed(0, 1)
+        .mapToObj(id -> "prefix" + id)
+        .collect(Collectors.toList());
+    Assert.assertEquals(expectedKeySubworkload1, subworkload1.getKeySpace().getKeys());
+
     final WorkloadDefinition subworkload2 = orderedSubworkloads.get(1);
-    Assert.assertEquals(2, subworkload2.getKeySpace().getMin());
-    Assert.assertEquals(3, subworkload2.getKeySpace().getMax());
+    final List<String> expectedKeySubworkload2 = IntStream
+        .rangeClosed(2, 3)
+        .mapToObj(id -> "prefix" + id)
+        .collect(Collectors.toList());
+    Assert.assertEquals(expectedKeySubworkload2, subworkload2.getKeySpace().getKeys());
+
     final WorkloadDefinition subworkload3 = orderedSubworkloads.get(2);
-    Assert.assertEquals(4, subworkload3.getKeySpace().getMin());
-    Assert.assertEquals(5, subworkload3.getKeySpace().getMax());
+    final List<String> expectedKeySubworkload3 = IntStream
+        .rangeClosed(4, 5)
+        .mapToObj(id -> "prefix" + id)
+        .collect(Collectors.toList());
+    Assert.assertEquals(expectedKeySubworkload3, subworkload3.getKeySpace().getKeys());
+
     final WorkloadDefinition subworkload4 = orderedSubworkloads.get(3);
-    Assert.assertEquals(6, subworkload4.getKeySpace().getMin());
-    Assert.assertEquals(6, subworkload4.getKeySpace().getMax());
+    final List<String> expectedKeySubworkload4 = IntStream
+        .rangeClosed(6, 6)
+        .mapToObj(id -> "prefix" + id)
+        .collect(Collectors.toList());
+    Assert.assertEquals(expectedKeySubworkload4, subworkload4.getKeySpace().getKeys());
+
     final WorkloadDefinition subworkload5 = orderedSubworkloads.get(4);
-    Assert.assertEquals(7, subworkload5.getKeySpace().getMin());
-    Assert.assertEquals(7, subworkload5.getKeySpace().getMax());
+    final List<String> expectedKeySubworkload5 = IntStream
+        .rangeClosed(7, 7)
+        .mapToObj(id -> "prefix" + id)
+        .collect(Collectors.toList());
+    Assert.assertEquals(expectedKeySubworkload5, subworkload5.getKeySpace().getKeys());
+
     final WorkloadDefinition subworkload6 = orderedSubworkloads.get(5);
-    Assert.assertEquals(8, subworkload6.getKeySpace().getMin());
-    Assert.assertEquals(8, subworkload6.getKeySpace().getMax());
+    final List<String> expectedKeySubworkload6 = IntStream
+        .rangeClosed(8, 8)
+        .mapToObj(id -> "prefix" + id)
+        .collect(Collectors.toList());
+    Assert.assertEquals(expectedKeySubworkload6, subworkload6.getKeySpace().getKeys());
+
     final WorkloadDefinition subworkload7 = orderedSubworkloads.get(6);
-    Assert.assertEquals(9, subworkload7.getKeySpace().getMin());
-    Assert.assertEquals(9, subworkload7.getKeySpace().getMax());
+    final List<String> expectedKeySubworkload7 = IntStream
+        .rangeClosed(9, 9)
+        .mapToObj(id -> "prefix" + id)
+        .collect(Collectors.toList());
+    Assert.assertEquals(expectedKeySubworkload7, subworkload7.getKeySpace().getKeys());
+  }
+
+  @Test
+  public void testDivideWithOneEmpty() {
+    final KeySpace keySpace = new KeySpace("prefix", 2);
+    final WorkloadDefinition workload = new WorkloadDefinition(keySpace, Duration.ofSeconds(1));
+    final Set<WorkloadDefinition> subworkloads = workload.divide(3);
+    Assert.assertEquals(3, subworkloads.size());
+    for (final WorkloadDefinition subworkload : subworkloads) {
+      Assert.assertEquals("prefix", subworkload.getKeySpace().getPrefix());
+      Assert.assertEquals(Duration.ofSeconds(1), subworkload.getPeriod());
+    }
+    final List<WorkloadDefinition> orderedSubworkloads = subworkloads.stream()
+        .sorted(Comparator.comparingInt(l -> l.getKeySpace().getMin()))
+        .collect(Collectors.toList());
+
+    final WorkloadDefinition subworkload1 = orderedSubworkloads.get(0);
+    final List<String> expectedKeySubworkload1 = List.of("prefix0");
+    Assert.assertEquals(expectedKeySubworkload1, subworkload1.getKeySpace().getKeys());
+
+    final WorkloadDefinition subworkload2 = orderedSubworkloads.get(1);
+    final List<String> expectedKeySubworkload2 = List.of("prefix1");
+    Assert.assertEquals(expectedKeySubworkload2, subworkload2.getKeySpace().getKeys());
+
+    final WorkloadDefinition subworkload3 = orderedSubworkloads.get(2);
+    final List<String> expectedKeySubworkload3 = List.of();
+    Assert.assertEquals(expectedKeySubworkload3, subworkload3.getKeySpace().getKeys());
+  }
+
+  @Test
+  public void testDivideWithTwoEmpty() {
+    final KeySpace keySpace = new KeySpace("prefix", 1);
+    final WorkloadDefinition workload = new WorkloadDefinition(keySpace, Duration.ofSeconds(1));
+    final Set<WorkloadDefinition> subworkloads = workload.divide(3);
+    Assert.assertEquals(3, subworkloads.size());
+    for (final WorkloadDefinition subworkload : subworkloads) {
+      Assert.assertEquals("prefix", subworkload.getKeySpace().getPrefix());
+      Assert.assertEquals(Duration.ofSeconds(1), subworkload.getPeriod());
+    }
+    final List<WorkloadDefinition> orderedSubworkloads = subworkloads.stream()
+        .sorted(Comparator.comparingInt(l -> l.getKeySpace().getMin()))
+        .collect(Collectors.toList());
+
+    final WorkloadDefinition subworkload1 = orderedSubworkloads.get(0);
+    final List<String> expectedKeySubworkload1 = List.of("prefix0");
+    Assert.assertEquals(expectedKeySubworkload1, subworkload1.getKeySpace().getKeys());
+
+    final WorkloadDefinition subworkload2 = orderedSubworkloads.get(1);
+    final List<String> expectedKeySubworkload2 = List.of();
+    Assert.assertEquals(expectedKeySubworkload2, subworkload2.getKeySpace().getKeys());
+
+    final WorkloadDefinition subworkload3 = orderedSubworkloads.get(2);
+    final List<String> expectedKeySubworkload3 = List.of();
+    Assert.assertEquals(expectedKeySubworkload3, subworkload3.getKeySpace().getKeys());
   }
 
 }