Introduce Range Query, Null and Generalized args generators in Java version

java/src/contention/abstractions/CompositionalMap.java

@@ -26,6 +26,10 @@ protected synchronized Vars initialValue() {
             return new Vars();
         }
     };
+
+    default public int rangeQuery(K lo, K hi) {
+        throw new UnsupportedOperationException("Call to a defaulted rangeQuery method - lacking implementation");
+    }
 
 	public V putIfAbsent(K k, V v);
 

java/src/contention/abstractions/DataStructure.java

@@ -9,6 +9,8 @@ public interface DataStructure<K> {
 
     K get(K key);
 
+    int rangeQuery(K lo, K hi);
+
     boolean removeAll(Collection<K> c);
 
     int size();

java/src/contention/benchmark/data/sctucrure/IntSetDataStructure.java

@@ -32,6 +32,11 @@ public boolean removeAll(Collection<Integer> c) {
         return dataStructure.removeAll(c);
     }
 
+    @Override
+    public int rangeQuery(Integer lo, Integer hi) {
+        throw new UnsupportedOperationException("IntSet DS does not currently support rangeQuery operation");
+    }
+
     @Override
     public int size() {
         return dataStructure.size();

java/src/contention/benchmark/data/sctucrure/MapDataStructure.java

@@ -4,6 +4,7 @@
 import contention.abstractions.DataStructure;
 
 import java.util.Collection;
+import java.util.NavigableMap;
 
 public class MapDataStructure<K> implements DataStructure<K> {
     private final CompositionalMap<K, K> dataStructure;
@@ -27,6 +28,11 @@ public K get(K key) {
         return dataStructure.get(key);
     }
 
+    @Override
+    public int rangeQuery(K lo, K hi) {
+        return dataStructure.rangeQuery(lo, hi);
+    }
+
     @Override
     public boolean removeAll(Collection<K> c) {
         return false;

java/src/contention/benchmark/data/sctucrure/SortedSetDataStructure.java

@@ -27,6 +27,11 @@ public K get(K key) {
         return dataStructure.contains(key) ? key : null;
     }
 
+    @Override
+    public int rangeQuery(K lo, K hi) {
+        throw new UnsupportedOperationException("SortedSet DS does not currently support rangeQuery operation");
+    }
+
     @Override
     public boolean removeAll(Collection<K> c) {
         return dataStructure.removeAll(c);

java/src/contention/benchmark/json/JsonExample.java

@@ -17,6 +17,8 @@
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
 
 public class JsonExample {
     public static ArgsGeneratorBuilder getDefaultArgsGeneratorBuilder() {
@@ -33,8 +35,8 @@ public static ArgsGeneratorBuilder getDefaultArgsGeneratorBuilder() {
     public static void makeSyntheticBinaryData() {
         try {
             FileOutputStream out = new FileOutputStream("test-binary-file");
-            byte []arr = {0, 0, 0, 1};
-            for (int i = 0; i<2048; ++i) {
+            byte[] arr = {0, 0, 0, 1};
+            for (int i = 0; i < 2048; ++i) {
                 out.write(arr);
             }
             out.close();
@@ -96,6 +98,28 @@ public static ThreadLoopBuilder getTemporaryOperationThreadLoopBuilder(ArgsGener
                 .setArgsGeneratorBuilder(argsGeneratorBuilder);
     }
 
+    public static ArgsGeneratorBuilder getNullArgsGeneratorBuilder() {
+        return (new NullArgsGeneratorBuilder());
+    }
+
+    public static ArgsGeneratorBuilder getRangeQueryArgsGeneratorBuilder() {
+        return new RangeQueryArgsGeneratorBuilder()
+                .setDistributionBuilder((new ZipfianDistributionBuilder()).setAlpha(1.0))
+                .setDataMapBuilder(new ArrayDataMapBuilder())
+                .setInterval(100);
+    }
+
+    public static ArgsGeneratorBuilder getGeneralizedArgsGeneratorBuilder(ArgsGeneratorBuilder inside) {
+        List<String> list = List.of("get", "insert", "remove");
+        return new GeneralizedArgsGeneratorBuilder()
+                .addArgsGeneratorBuilder(List.of("get"), inside)
+                .addArgsGeneratorBuilder(List.of("insert"), getCreakersAndWaveArgsGeneratorBuilder())
+                .addArgsGeneratorBuilder(List.of("remove"), getDefaultArgsGeneratorBuilder());
+//                .addArgsGeneratorBuilder(List.of("rangeQuery"), getRangeQueryArgsGeneratorBuilder());
+//         .setDistributionBuilder((new ZipfianDistributionBuilder()).setAlpha(1.0))
+//         .setDataMapBuilder(new ArrayDataMapBuilder()));
+    }
+
     public static void main(String[] args) {
         /**
          * The first step is the creation the BenchParameters class.
@@ -132,14 +156,15 @@ public static void main(String[] args) {
          * TemporarySkewedArgsGeneratorBuilder and CreakersAndWaveArgsGeneratorBuilder are also presented
          * in the corresponding functions
          */
-        ArgsGeneratorBuilder argsGeneratorBuilder = getFileBasedArgsGeneratorBuilder();
-        //ArgsGeneratorBuilder argsGeneratorBuilder = getDefaultArgsGeneratorBuilder();
+//        ArgsGeneratorBuilder argsGeneratorBuilder = getFileBasedArgsGeneratorBuilder();
+        ArgsGeneratorBuilder argsGeneratorBuilder = getDefaultArgsGeneratorBuilder();
+        ArgsGeneratorBuilder argsGeneratorBuilderActual = getGeneralizedArgsGeneratorBuilder(argsGeneratorBuilder);
 
         /**
          * in addition to the DefaultThreadLoopBuilder,
          * TemporaryOperationThreadLoopBuilder is also presented in the corresponding function
          */
-        ThreadLoopBuilder threadLoopBuilder = getDefaultThreadLoopBuilder(argsGeneratorBuilder);
+        ThreadLoopBuilder threadLoopBuilder = getDefaultThreadLoopBuilder(argsGeneratorBuilderActual);
 
         /**
          * now add the ThreadLoopBuilders (you can add several different)

java/src/contention/benchmark/statistic/BenchStatistic.java

@@ -44,6 +44,10 @@ public String toString(int indents) {
                         commonStatistic.numRemove,
                         (double) commonStatistic.numRemove / (double) commonStatistic.total,
                         indents + 1))
+                .append(indentedTitleWithDataPercent("|--rangeQuery succ.",
+                        commonStatistic.numRangeQuery,
+                        (double) commonStatistic.numRangeQuery / (double) commonStatistic.total,
+                        indents + 1))
                 .append(indentedTitleWithDataPercent("|--addAll succ.",
                         commonStatistic.numAddAll,
                         (double) commonStatistic.numAddAll / (double) commonStatistic.total,

java/src/contention/benchmark/statistic/ThreadStatistic.java

@@ -11,6 +11,7 @@ public class ThreadStatistic {
      */
     public long numAdd = 0;
     public long numRemove = 0;
+    public long numRangeQuery = 0;
     public long numAddAll = 0;
     public long numRemoveAll = 0;
     public long numSize = 0;
@@ -33,6 +34,7 @@ public void reset() {
         total = 0;
         numAdd = 0;
         numRemove = 0;
+        numRangeQuery = 0;
         numAddAll = 0;
         numRemoveAll = 0;
         numSize = 0;
@@ -47,6 +49,7 @@ public void reset() {
     public void add(ThreadStatistic stats) {
         total += stats.total;
         numAdd += stats.numAdd;
+        numRangeQuery += stats.numRangeQuery;
         numRemove += stats.numRemove;
         numAddAll += stats.numAddAll;
         numRemoveAll += stats.numRemoveAll;

java/src/contention/benchmark/workload/args/generators/abstractions/ArgsGenerator.java

@@ -1,9 +1,12 @@
 package contention.benchmark.workload.args.generators.abstractions;
+import contention.benchmark.tools.Pair;
 
 public interface ArgsGenerator {
     int nextGet();
 
     int nextInsert();
 
     int nextRemove();
+
+    Pair<Integer, Integer> nextRange();
 }

java/src/contention/benchmark/workload/args/generators/builders/CreakersAndWaveArgsGeneratorBuilder.java

@@ -1,14 +1,14 @@
 package contention.benchmark.workload.args.generators.builders;
 
+import contention.benchmark.workload.args.generators.abstractions.ArgsGenerator;
+import contention.benchmark.workload.args.generators.abstractions.ArgsGeneratorBuilder;
 import contention.benchmark.workload.args.generators.impls.CreakersAndWaveArgsGenerator;
+import contention.benchmark.workload.data.map.abstractions.DataMapBuilder;
 import contention.benchmark.workload.data.map.builders.ArrayDataMapBuilder;
 import contention.benchmark.workload.distributions.abstractions.DistributionBuilder;
 import contention.benchmark.workload.distributions.abstractions.MutableDistributionBuilder;
 import contention.benchmark.workload.distributions.builders.UniformDistributionBuilder;
 import contention.benchmark.workload.distributions.builders.ZipfianDistributionBuilder;
-import contention.benchmark.workload.args.generators.abstractions.ArgsGeneratorBuilder;
-import contention.benchmark.workload.data.map.abstractions.DataMapBuilder;
-import contention.benchmark.workload.args.generators.abstractions.ArgsGenerator;
 
 import java.util.concurrent.atomic.AtomicInteger;
 

java/src/contention/benchmark/workload/args/generators/builders/CreakersAndWavePrefillArgsGeneratorBuilder.java

@@ -1,10 +1,10 @@
 package contention.benchmark.workload.args.generators.builders;
 
+import contention.benchmark.workload.args.generators.abstractions.ArgsGenerator;
 import contention.benchmark.workload.args.generators.abstractions.ArgsGeneratorBuilder;
 import contention.benchmark.workload.args.generators.impls.CreakersAndWavePrefillArgsGenerator;
 import contention.benchmark.workload.data.map.abstractions.DataMapBuilder;
 import contention.benchmark.workload.data.map.builders.ArrayDataMapBuilder;
-import contention.benchmark.workload.args.generators.abstractions.ArgsGenerator;
 
 import static contention.benchmark.tools.StringFormat.indentedTitle;
 import static contention.benchmark.tools.StringFormat.indentedTitleWithData;

java/src/contention/benchmark/workload/args/generators/builders/DefaultArgsGeneratorBuilder.java

@@ -1,11 +1,11 @@
 package contention.benchmark.workload.args.generators.builders;
 
-import contention.benchmark.workload.args.generators.impls.DefaultArgsGenerator;
-import contention.benchmark.workload.distributions.abstractions.DistributionBuilder;
-import contention.benchmark.workload.distributions.builders.UniformDistributionBuilder;
 import contention.benchmark.workload.args.generators.abstractions.ArgsGeneratorBuilder;
+import contention.benchmark.workload.args.generators.impls.DefaultArgsGenerator;
 import contention.benchmark.workload.data.map.abstractions.DataMapBuilder;
 import contention.benchmark.workload.data.map.builders.IdDataMapBuilder;
+import contention.benchmark.workload.distributions.abstractions.DistributionBuilder;
+import contention.benchmark.workload.distributions.builders.UniformDistributionBuilder;
 
 import static contention.benchmark.tools.StringFormat.indentedTitle;
 import static contention.benchmark.tools.StringFormat.indentedTitleWithData;
@@ -43,7 +43,7 @@ public DefaultArgsGenerator build() {
     @Override
     public StringBuilder toStringBuilder(int indents) {
         return new StringBuilder()
-                .append(indentedTitleWithData("Type", "Default", indents))
+                .append(indentedTitleWithData("Type", "DEFAULT", indents))
                 .append(indentedTitle("Distribution", indents))
                 .append(distributionBuilder.toStringBuilder(indents + 1))
                 .append(indentedTitle("DataMap", indents))

java/src/contention/benchmark/workload/args/generators/builders/GeneralizedArgsGeneratorBuilder.java

@@ -0,0 +1,91 @@
+package contention.benchmark.workload.args.generators.builders;
+
+import contention.benchmark.workload.args.generators.abstractions.ArgsGenerator;
+import contention.benchmark.workload.args.generators.abstractions.ArgsGeneratorBuilder;
+import contention.benchmark.workload.args.generators.impls.GeneralizedArgsGenerator;
+
+import java.util.*;
+
+import static contention.benchmark.tools.StringFormat.indentedTitle;
+import static contention.benchmark.tools.StringFormat.indentedTitleWithData;
+
+public class GeneralizedArgsGeneratorBuilder implements ArgsGeneratorBuilder {
+    private static final Set<String> OPER_TYPES = Set.of("get", "insert", "remove", "rangeQuery");
+
+    private static class BuilderOperations {
+        ArgsGeneratorBuilder builder;
+        List<String> operations;
+
+        BuilderOperations(ArgsGeneratorBuilder builder, List<String> operations) {
+            this.builder = builder;
+            this.operations = operations;
+        }
+    }
+
+    private List<BuilderOperations> argsGeneratorBuilders = new ArrayList<>();
+    private Set<String> undecOperTypes = new HashSet<>(OPER_TYPES);
+
+    public GeneralizedArgsGeneratorBuilder addArgsGeneratorBuilder(List<String> opers,
+                                                                   ArgsGeneratorBuilder argsGenBuilder) {
+        for (String operType : opers) {
+            if (!OPER_TYPES.contains(operType)) {
+                throw new IllegalArgumentException("Unsupported operation type: " + operType);
+            }
+            if (!undecOperTypes.contains(operType)) {
+                throw new IllegalArgumentException("Multiple declaration of operation type: " + operType);
+            }
+            undecOperTypes.remove(operType);
+        }
+
+        argsGeneratorBuilders.add(new BuilderOperations(argsGenBuilder, opers));
+        return this;
+    }
+
+    @Override
+    public ArgsGeneratorBuilder init(int range) {
+        if (!undecOperTypes.isEmpty()) {
+            addArgsGeneratorBuilder(
+                    new ArrayList<>(undecOperTypes),
+                    new NullArgsGeneratorBuilder()
+            );
+        }
+
+        for (BuilderOperations currentBuilder : argsGeneratorBuilders) {
+            currentBuilder.builder.init(range);
+        }
+        return this;
+    }
+
+    @Override
+    public ArgsGenerator build() {
+        Map<String, ArgsGenerator> built = new HashMap<>();
+        for (BuilderOperations currentBuilder : argsGeneratorBuilders) {
+            ArgsGenerator generator = currentBuilder.builder.build();
+            for (String operType : currentBuilder.operations) {
+                built.put(operType, generator);
+            }
+        }
+
+        return new GeneralizedArgsGenerator(
+                built.get("get"),
+                built.get("insert"),
+                built.get("remove"),
+                built.get("rangeQuery")
+        );
+    }
+
+    @Override
+    public StringBuilder toStringBuilder(int indents) {
+        StringBuilder sb = new StringBuilder()
+                .append(indentedTitleWithData("Type", "GENERALIZED", indents));
+
+        for (BuilderOperations currentBuilder : argsGeneratorBuilders) {
+            String opers = String.join(", ", currentBuilder.operations);
+            sb.append(indentedTitle("Args Generators (" + opers + ")", indents));
+            sb.append(currentBuilder.builder.toStringBuilder(indents + 1));
+        }
+
+        return sb;
+    }
+
+}

java/src/contention/benchmark/workload/args/generators/builders/LeafInsertArgsGeneratorBuilder.java

@@ -27,6 +27,6 @@ public LeafInsertArgsGenerator build() {
     @Override
     public StringBuilder toStringBuilder(int indents) {
         return new StringBuilder()
-                .append(indentedTitleWithData("Type", "LeafInsert", indents));
+                .append(indentedTitleWithData("Type", "LEAF_INSERT", indents));
     }
 }

java/src/contention/benchmark/workload/args/generators/builders/LeafsExtensionHandshakeArgsGeneratorBuilder.java

@@ -1,10 +1,10 @@
 package contention.benchmark.workload.args.generators.builders;
 
+import contention.benchmark.workload.args.generators.abstractions.ArgsGeneratorBuilder;
+import contention.benchmark.workload.args.generators.impls.LeafsExtensionHandshakeArgsGenerator;
 import contention.benchmark.workload.data.map.abstractions.DataMapBuilder;
 import contention.benchmark.workload.data.map.builders.IdDataMapBuilder;
 import contention.benchmark.workload.distributions.abstractions.MutableDistributionBuilder;
-import contention.benchmark.workload.args.generators.abstractions.ArgsGeneratorBuilder;
-import contention.benchmark.workload.args.generators.impls.LeafsExtensionHandshakeArgsGenerator;
 import contention.benchmark.workload.distributions.builders.UniformDistributionBuilder;
 import contention.benchmark.workload.distributions.builders.ZipfianDistributionBuilder;
 

java/src/contention/benchmark/workload/args/generators/builders/LeafsHandshakeArgsGeneratorBuilder.java

@@ -2,10 +2,10 @@
 
 import contention.benchmark.workload.args.generators.abstractions.ArgsGeneratorBuilder;
 import contention.benchmark.workload.args.generators.impls.LeafsHandshakeArgsGenerator;
+import contention.benchmark.workload.data.map.abstractions.DataMapBuilder;
 import contention.benchmark.workload.data.map.builders.IdDataMapBuilder;
 import contention.benchmark.workload.distributions.abstractions.DistributionBuilder;
 import contention.benchmark.workload.distributions.abstractions.MutableDistributionBuilder;
-import contention.benchmark.workload.data.map.abstractions.DataMapBuilder;
 import contention.benchmark.workload.distributions.builders.UniformDistributionBuilder;
 import contention.benchmark.workload.distributions.builders.ZipfianDistributionBuilder;
 

java/src/contention/benchmark/workload/args/generators/builders/NullArgsGeneratorBuilder.java

@@ -0,0 +1,29 @@
+package contention.benchmark.workload.args.generators.builders;
+
+import contention.benchmark.workload.args.generators.abstractions.ArgsGenerator;
+import contention.benchmark.workload.args.generators.abstractions.ArgsGeneratorBuilder;
+import contention.benchmark.workload.args.generators.impls.NullArgsGenerator;
+
+public class NullArgsGeneratorBuilder implements ArgsGeneratorBuilder {
+
+    public NullArgsGeneratorBuilder() {
+    }
+
+    @Override
+    public ArgsGeneratorBuilder init(int range) {
+        return this;
+    }
+
+    @Override
+    public ArgsGenerator build() {
+        return new NullArgsGenerator();
+    }
+
+    @Override
+    public StringBuilder toStringBuilder(int indents) {
+        StringBuilder sb = new StringBuilder();
+        String indentStr = "    ".repeat(indents);
+        sb.append(indentStr).append("Type: NULL\n");
+        return sb;
+    }
+}