save benchmark results, add notes as comments

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

@@ -7,6 +7,7 @@ import theodolite.util.Resource
 class TestBenchmarkExecutor(val mockResults: Array<Array<Boolean>>): BenchmarkExecutor {
 
     override fun runExperiment(load: LoadDimension, res: Resource): Boolean {
+        System.out.println("load :" + load.get().toString() + ", res: " + res.get().toString())
         return this.mockResults[load.get()][res.get()]
     }
 }
\ No newline at end of file

theodolite-quarkus/src/main/kotlin/theodolite/strategies/restriction/LowerBoundRestriction.kt

@@ -3,10 +3,12 @@ package theodolite.strategies.restriction
 import theodolite.util.Results
 import theodolite.util.LoadDimension
 import theodolite.util.Resource
+import kotlin.math.max
 
-class LowerBoundRestriction(results: Results, loads: List<LoadDimension>) : RestrictionStrategy(results, loads) {
+class LowerBoundRestriction(results: Results) : RestrictionStrategy(results) {
     override fun next(load: LoadDimension, resources: List<Resource>): List<Resource> {
-            var lowerBound: Resource? = this.results.getRequiredInstances(load)
+            val maxLoad: LoadDimension? = this.results.getMaxBenchmarkedLoad(load)
+            var lowerBound: Resource? = this.results.getRequiredInstances(maxLoad)
             if(lowerBound == null) {
                 lowerBound = Resource(0) // TODO handle the null case
             }

theodolite-quarkus/src/main/kotlin/theodolite/strategies/restriction/RestrictionStrategy.kt

@@ -4,6 +4,6 @@ import theodolite.util.Results
 import theodolite.util.LoadDimension
 import theodolite.util.Resource
 
-abstract class RestrictionStrategy(val results: Results, val loads: List<LoadDimension>) {
+abstract class RestrictionStrategy(val results: Results) {
     public abstract fun next(load: LoadDimension, resources: List<Resource>): List<Resource>;
 }
\ No newline at end of file

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

@@ -3,9 +3,10 @@ package theodolite.strategies.searchstrategy
 import theodolite.execution.BenchmarkExecutor
 import theodolite.util.LoadDimension
 import theodolite.util.Resource
+import theodolite.util.Results
 import java.lang.IllegalArgumentException
 
-class BinarySearch(benchmarkExecutor: BenchmarkExecutor) : SearchStrategy(benchmarkExecutor) {
+class BinarySearch(benchmarkExecutor: BenchmarkExecutor, results: Results) : SearchStrategy(benchmarkExecutor, results) {
     override fun findSuitableResources(load: LoadDimension, resources: List<Resource>): Resource? {
         val result =  search(load, resources, 0, resources.size - 1)
         if( result == -1 ) {

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

@@ -4,14 +4,15 @@ import theodolite.execution.BenchmarkExecutor
 import theodolite.strategies.restriction.RestrictionStrategy
 import theodolite.util.LoadDimension
 import theodolite.util.Resource
+import theodolite.util.Results
 
-class CompositeStrategy(benchmarkExecutor: BenchmarkExecutor, val searchStrategy: SearchStrategy, val restrictionStrategies: List<RestrictionStrategy>) : SearchStrategy(benchmarkExecutor) {
+class CompositeStrategy(benchmarkExecutor: BenchmarkExecutor, val searchStrategy: SearchStrategy, val restrictionStrategies: List<RestrictionStrategy>, results: Results) : SearchStrategy(benchmarkExecutor, results) {
 
     override fun findSuitableResources(load: LoadDimension,resources: List<Resource>): Resource? {
-        var restrictedResources: List<Resource> = resources
+        var restricted = resources
         for (strategy in this.restrictionStrategies) {
-            restrictedResources.intersect(strategy.next(load, resources))
+            restricted = restricted.intersect(strategy.next(load, resources)).toList() // erstellt das eine liste oder verändert das die liste?
         }
-        return this.searchStrategy.findSuitableResources(load, restrictedResources)
+        return this.searchStrategy.findSuitableResources(load, restricted)
     }
 }
\ No newline at end of file

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

@@ -3,12 +3,18 @@ package theodolite.strategies.searchstrategy
 import theodolite.execution.BenchmarkExecutor
 import theodolite.util.LoadDimension
 import theodolite.util.Resource
+import theodolite.util.Results
 
-class LinearSearch(benchmarkExecutor: BenchmarkExecutor) : SearchStrategy(benchmarkExecutor) {
+class LinearSearch(benchmarkExecutor: BenchmarkExecutor, results: Results) : SearchStrategy(benchmarkExecutor, results) {
 
     override fun findSuitableResources(load: LoadDimension, resources: List<Resource>): Resource? {
         for (res in resources) {
-            if (this.benchmarkExecutor.runExperiment(load, res)) return res;
+            if (this.benchmarkExecutor.runExperiment(load, res)) {
+                this.results.setResult(Pair(load, res), true)
+                return res
+            } else {
+                this.results.setResult(Pair(load, res), false)
+            }
         }
         return null;
     }

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

@@ -3,7 +3,8 @@ package theodolite.strategies.searchstrategy
 import theodolite.execution.BenchmarkExecutor
 import theodolite.util.LoadDimension
 import theodolite.util.Resource
+import theodolite.util.Results
 
-abstract class SearchStrategy(val benchmarkExecutor: BenchmarkExecutor) {
+abstract class SearchStrategy(val benchmarkExecutor: BenchmarkExecutor, val results: Results) {
     abstract fun findSuitableResources(load: LoadDimension, resources: List<Resource>): Resource?;
 }
\ No newline at end of file

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

 package theodolite.util
 
-class LoadDimension(val number: Int) {
+class LoadDimension(val number: Int) { // data class ?
     public fun get(): Int {
         return this.number;
     }
@@ -14,4 +14,4 @@ class LoadDimension(val number: Int) {
     override fun hashCode(): Int {
         return this.get().hashCode()
     }
-}
+}
\ No newline at end of file

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

@@ -6,7 +6,7 @@ import kotlin.math.exp
 
 class Results {
     // load, instances
-    private val results: MutableMap<Pair<LoadDimension, Resource>, Boolean> = mutableMapOf()
+    private val results: MutableMap<Pair<LoadDimension, Resource>, Boolean> = mutableMapOf() // multi map guava
 
     public fun setResult(experiment: Pair<LoadDimension, Resource>, successful: Boolean) {
         this.results.put(experiment, successful)
@@ -16,7 +16,7 @@ class Results {
         return this.results.get(experiment)
     }
 
-    public fun getRequiredInstances(load: LoadDimension): Resource? {
+    public fun getRequiredInstances(load: LoadDimension?): Resource? {
         var requiredInstances: Resource? = null;
         for(experiment in results) {
             if(experiment.key.first == load && experiment.value){
@@ -29,4 +29,20 @@ class Results {
         }
         return requiredInstances
     }
+
+    public fun getMaxBenchmarkedLoad(load: LoadDimension): LoadDimension? {
+        var maxBenchmarkedLoad: LoadDimension = LoadDimension(0)
+        for(experiment in results) {
+            if (experiment.value) {
+                if(experiment.key.first.get() <= load.get()) {
+                    if (experiment.value && maxBenchmarkedLoad == null) {
+                        maxBenchmarkedLoad = experiment.key.first
+                    } else if (experiment.value && maxBenchmarkedLoad.get() < experiment.key.first.get()) {
+                        maxBenchmarkedLoad = experiment.key.first
+                    }
+                }
+            }
+        }
+        return maxBenchmarkedLoad
+    }
 }
\ No newline at end of file

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

@@ -29,10 +29,10 @@ class CompositeStrategyTest {
         val mockLoads: List<LoadDimension> =  (0..6).map{number -> LoadDimension(number)}
         val mockResources: List<Resource> =  (0..6).map{number -> Resource(number)}
         val benchmarkExecutor: TestBenchmarkExecutor = TestBenchmarkExecutor(mockResults)
-        val linearSearch: LinearSearch = LinearSearch(benchmarkExecutor);
         val results: Results = Results();
-        val lowerBoundRestriction: LowerBoundRestriction = LowerBoundRestriction(results, mockLoads);
-        val strategy: CompositeStrategy = CompositeStrategy(benchmarkExecutor, linearSearch, listOf(lowerBoundRestriction))
+        val linearSearch: LinearSearch = LinearSearch(benchmarkExecutor, results);
+        val lowerBoundRestriction: LowerBoundRestriction = LowerBoundRestriction(results);
+        val strategy: CompositeStrategy = CompositeStrategy(benchmarkExecutor, linearSearch, listOf(lowerBoundRestriction), results)
 
         val actual: ArrayList<Resource?> = ArrayList<Resource?>()
         val expected: ArrayList<Resource?> = ArrayList(listOf(0,2,2,3,4,6).map{ x -> Resource(x)})
@@ -59,10 +59,10 @@ class CompositeStrategyTest {
         val mockLoads: List<LoadDimension> =  (0..6).map{number -> LoadDimension(number)}
         val mockResources: List<Resource> =  (0..6).map{number -> Resource(number)}
         val benchmarkExecutor: TestBenchmarkExecutor = TestBenchmarkExecutor(mockResults)
-        val binarySearch: BinarySearch = BinarySearch(benchmarkExecutor);
         val results: Results = Results();
-        val lowerBoundRestriction: LowerBoundRestriction = LowerBoundRestriction(results, mockLoads);
-        val strategy: CompositeStrategy = CompositeStrategy(benchmarkExecutor, binarySearch, listOf(lowerBoundRestriction))
+        val binarySearch: BinarySearch = BinarySearch(benchmarkExecutor, results);
+        val lowerBoundRestriction: LowerBoundRestriction = LowerBoundRestriction(results);
+        val strategy: CompositeStrategy = CompositeStrategy(benchmarkExecutor, binarySearch, listOf(lowerBoundRestriction), results) // sets instead of lists
 
         val actual: ArrayList<Resource?> = ArrayList<Resource?>()
         val expected: ArrayList<Resource?> = ArrayList(listOf(0,2,2,3,4,6).map{ x -> Resource(x)})