Fix serialization and workload division

benchmarks/workload-generator-commons/src/main/java/theodolite/commons/workloadgeneration/KeySpace.java

 package theodolite.commons.workloadgeneration;
 
+import java.io.Serializable;
 import java.util.Collection;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -9,7 +10,9 @@ import theodolite.commons.workloadgeneration.generators.AbstractWorkloadGenerato
  * Wrapper class for the definition of the Keys that should be used by the
  * {@link AbstractWorkloadGenerator}.
  */
-public class KeySpace {
+public class KeySpace implements Serializable {
+
+  private static final long serialVersionUID = 7343135392720315515L; // NOPMD
 
   private final String prefix;
   private final int min;

benchmarks/workload-generator-commons/src/main/java/theodolite/commons/workloadgeneration/WorkloadDefinition.java

 package theodolite.commons.workloadgeneration;
 
+import java.io.Serializable;
 import java.time.Duration;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
-public class WorkloadDefinition {
+public class WorkloadDefinition implements Serializable {
+
+  private static final long serialVersionUID = -8337364281221817001L; // NOPMD
 
   private final KeySpace keySpace;
   private final Duration period;
@@ -31,12 +34,21 @@ public class WorkloadDefinition {
   }
 
   public Set<WorkloadDefinition> divide(final int parts) {
-    final int size = (this.keySpace.getCount() + parts - 1) / parts; // = ceil(count/parts)
-    return IntStream.range(0, parts)
-        .mapToObj(part -> new KeySpace(
+    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)
+        .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;
+          return new KeySpace(
               this.keySpace.getPrefix(),
-            this.keySpace.getMin() + part * size,
-            Math.min(this.keySpace.getMin() + (part + 1) * size - 1, this.keySpace.getMax())))
+              start,
+              end);
+        })
         .map(keySpace -> new WorkloadDefinition(
             keySpace,
             this.period))

benchmarks/workload-generator-commons/src/test/java/theodolite/commons/workloadgeneration/KeySpaceTest.java

-package theodolite.commons.workloadgeneration.dimensions;
+package theodolite.commons.workloadgeneration;
 
 import org.junit.Assert;
 import org.junit.Test;

benchmarks/workload-generator-commons/src/test/java/theodolite/commons/workloadgeneration/WorkloadDefinitionTest.java

-package theodolite.commons.workloadgeneration.misc;
+package theodolite.commons.workloadgeneration;
 
 import java.time.Duration;
 import java.util.Comparator;
@@ -7,10 +7,8 @@ import java.util.Set;
 import java.util.stream.Collectors;
 import org.junit.Assert;
 import org.junit.Test;
-import theodolite.commons.workloadgeneration.KeySpace;
-import theodolite.commons.workloadgeneration.WorkloadDefinition;
 
-public class WorkloadDefinition2Test {
+public class WorkloadDefinitionTest {
 
   @Test
   public void testDivideByOneAmount() {
@@ -54,10 +52,46 @@ public class WorkloadDefinition2Test {
     Assert.assertEquals(33, subworkload1.getKeySpace().getMax());
     final WorkloadDefinition subworkload2 = orderedSubworkloads.get(1);
     Assert.assertEquals(34, subworkload2.getKeySpace().getMin());
-    Assert.assertEquals(67, subworkload2.getKeySpace().getMax());
+    Assert.assertEquals(66, subworkload2.getKeySpace().getMax());
     final WorkloadDefinition subworkload3 = orderedSubworkloads.get(2);
-    Assert.assertEquals(68, subworkload3.getKeySpace().getMin());
+    Assert.assertEquals(67, subworkload3.getKeySpace().getMin());
     Assert.assertEquals(99, subworkload3.getKeySpace().getMax());
   }
 
+  @Test
+  public void testDivideMany() {
+    final KeySpace keySpace = new KeySpace("prefix", 10);
+    final WorkloadDefinition workload = new WorkloadDefinition(keySpace, Duration.ofSeconds(1));
+    final Set<WorkloadDefinition> subworkloads = workload.divide(7);
+    Assert.assertEquals(7, 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);
+    Assert.assertEquals(0, subworkload1.getKeySpace().getMin());
+    Assert.assertEquals(1, subworkload1.getKeySpace().getMax());
+    final WorkloadDefinition subworkload2 = orderedSubworkloads.get(1);
+    Assert.assertEquals(2, subworkload2.getKeySpace().getMin());
+    Assert.assertEquals(3, subworkload2.getKeySpace().getMax());
+    final WorkloadDefinition subworkload3 = orderedSubworkloads.get(2);
+    Assert.assertEquals(4, subworkload3.getKeySpace().getMin());
+    Assert.assertEquals(5, subworkload3.getKeySpace().getMax());
+    final WorkloadDefinition subworkload4 = orderedSubworkloads.get(3);
+    Assert.assertEquals(6, subworkload4.getKeySpace().getMin());
+    Assert.assertEquals(6, subworkload4.getKeySpace().getMax());
+    final WorkloadDefinition subworkload5 = orderedSubworkloads.get(4);
+    Assert.assertEquals(7, subworkload5.getKeySpace().getMin());
+    Assert.assertEquals(7, subworkload5.getKeySpace().getMax());
+    final WorkloadDefinition subworkload6 = orderedSubworkloads.get(5);
+    Assert.assertEquals(8, subworkload6.getKeySpace().getMin());
+    Assert.assertEquals(8, subworkload6.getKeySpace().getMax());
+    final WorkloadDefinition subworkload7 = orderedSubworkloads.get(6);
+    Assert.assertEquals(9, subworkload7.getKeySpace().getMin());
+    Assert.assertEquals(9, subworkload7.getKeySpace().getMax());
+  }
+
 }