Add executionDuration to BenchmarkExecutor

theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutor.kt

@@ -4,7 +4,8 @@ import theodolite.util.Benchmark
 import theodolite.util.LoadDimension
 import theodolite.util.Resource
 import theodolite.util.Results
+import java.time.Duration
 
-abstract class BenchmarkExecutor(val benchmark: Benchmark, val results: Results) {
+abstract class BenchmarkExecutor(val benchmark: Benchmark, val results: Results, val executionDuration: Duration) {
     abstract fun runExperiment(load: LoadDimension, res: Resource): Boolean;
 }
\ No newline at end of file

theodolite-quarkus/src/main/kotlin/theodolite/execution/KafkaBenchmarkExecutor.kt

@@ -4,12 +4,13 @@ import theodolite.util.Benchmark
 import theodolite.util.LoadDimension
 import theodolite.util.Resource
 import theodolite.util.Results
+import java.time.Duration
 
-class KafkaBenchmarkExecutor(benchmark: Benchmark, results: Results) : BenchmarkExecutor(benchmark, results) {
+class KafkaBenchmarkExecutor(benchmark: Benchmark, results: Results, executionDuration: Duration) : BenchmarkExecutor(benchmark, results, executionDuration) {
     override fun runExperiment(load: LoadDimension, res: Resource): Boolean {
         benchmark.start()
         // wait
-        benchmark.stop();
+        benchmark.stop()
         // evaluate
         val result = false // if success else false
         this.results.setResult(Pair(load, res), result)

theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteExecutor.kt

@@ -4,12 +4,14 @@ import theodolite.strategies.restriction.LowerBoundRestriction
 import theodolite.strategies.searchstrategy.CompositeStrategy
 import theodolite.strategies.searchstrategy.LinearSearch
 import theodolite.util.*
+import java.time.Duration
 
 class TheodoliteExecutor() {
     private fun loadConfig(): Config {
-        val benchmark: Benchmark = KafkaBenchmark()
+        val benchmark: Benchmark = KafkaBenchmark(emptyMap())
         val results: Results = Results()
-        val executor: BenchmarkExecutor = KafkaBenchmarkExecutor(benchmark, results)
+        val executionDuration = Duration.ofSeconds(60*5 )
+        val executor: BenchmarkExecutor = KafkaBenchmarkExecutor(benchmark, results, executionDuration)
 
         val restrictionStrategy = LowerBoundRestriction(results)
         val searchStrategy = LinearSearch(executor, results)
@@ -17,7 +19,8 @@ class TheodoliteExecutor() {
         return Config(
             loads = (0..6).map{ number -> LoadDimension(number) },
             resources = (0..6).map{ number -> Resource(number) },
-            compositeStrategy = CompositeStrategy(executor, searchStrategy, restrictionStrategies = setOf(restrictionStrategy), results = results)
+            compositeStrategy = CompositeStrategy(executor, searchStrategy, restrictionStrategies = setOf(restrictionStrategy), results = results),
+            executionDuration = executionDuration
         )
     }
 

theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/BinarySearch.kt

@@ -20,7 +20,7 @@ class BinarySearch(benchmarkExecutor: BenchmarkExecutor, results: Results) : Sea
             throw IllegalArgumentException()
         }
         if (lower == upper ) {
-            if (this.benchmarkExecutor.runExperiment(load, resources[upper])) return upper;
+            if (this.benchmarkExecutor.runExperiment(load, resources[lower])) return lower;
             else {
                 if (lower + 1 == resources.size) return - 1
                 return lower + 1;

theodolite-quarkus/src/main/kotlin/theodolite/util/Benchmark.kt

 package theodolite.util
 
 // todo: needs cluster and resource config
-interface Benchmark {
+abstract class Benchmark(val config: Map<String, Any>) {
+    abstract fun start();
 
-    fun start();
-
-    fun stop();
+    abstract fun stop();
 }
\ No newline at end of file

theodolite-quarkus/src/main/kotlin/theodolite/util/Config.kt

@@ -3,11 +3,13 @@ package theodolite.util
 import theodolite.strategies.restriction.RestrictionStrategy
 import theodolite.strategies.searchstrategy.CompositeStrategy
 import theodolite.strategies.searchstrategy.SearchStrategy
+import java.time.Duration
 
 data class Config(
     val loads: List<LoadDimension>,
     val resources: List<Resource>,
-    val compositeStrategy: CompositeStrategy
+    val compositeStrategy: CompositeStrategy,
+    val executionDuration: Duration
 ) {
 
 }
\ No newline at end of file

theodolite-quarkus/src/main/kotlin/theodolite/util/KafkaBenchmark.kt

 package theodolite.util
 
-class KafkaBenchmark: Benchmark {
+class KafkaBenchmark(config: Map<String, Any>): Benchmark(config) {
 
     override fun start() {
         TODO("Not yet implemented")

theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt

@@ -8,6 +8,8 @@ import theodolite.strategies.searchstrategy.BinarySearch
 import theodolite.strategies.restriction.LowerBoundRestriction
 import theodolite.strategies.searchstrategy.CompositeStrategy
 import theodolite.execution.TestBenchmarkExecutor
+import theodolite.strategies.restriction.RestrictionStrategy
+import theodolite.strategies.searchstrategy.SearchStrategy
 import theodolite.util.*
 
 @QuarkusTest
@@ -75,6 +77,34 @@ class CompositeStrategyTest {
         assertEquals(actual, expected)
     }
 
+    @Test
+    fun testEnd2EndBinarySearch2() {
+        val mockResults = arrayOf(
+            arrayOf( true , true , true , true , true , true , true, true),
+            arrayOf( false, false, true , true , true , true , true, true),
+            arrayOf( false, false, true , true , true , true , true, true),
+            arrayOf( false, false, false, true , true , true , true, true),
+            arrayOf( false, false, false, false, true , true , true, true),
+            arrayOf( false, false, false, false, false, false, true, true),
+            arrayOf( false, false, false, false, false, false, false, true)
+        )
+        val mockLoads: List<LoadDimension> =  (0..6).map{number -> LoadDimension(number)}
+        val mockResources: List<Resource> =  (0..7).map{number -> Resource(number)}
+        val results: Results = Results();
+        val benchmark = TestBenchmark()
+        val benchmarkExecutor: TestBenchmarkExecutor = TestBenchmarkExecutor(mockResults, benchmark, results)
+        val binarySearch: BinarySearch = BinarySearch(benchmarkExecutor, results);
+        val lowerBoundRestriction: LowerBoundRestriction = LowerBoundRestriction(results);
+        val strategy: CompositeStrategy = CompositeStrategy(benchmarkExecutor, binarySearch, setOf(lowerBoundRestriction), results) // sets instead of lists
+
+        val actual: ArrayList<Resource?> = ArrayList<Resource?>()
+        val expected: ArrayList<Resource?> = ArrayList(listOf(0,2,2,3,4,6,7).map{ x -> Resource(x)})
 
+        for(load in mockLoads) {
+            actual.add(strategy.findSuitableResources(load, mockResources))
+        }
+
+        assertEquals(actual, expected)
+    }
 
 }
\ No newline at end of file