minfun complete

nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/findmax/CMD_findmax.java

@@ -25,10 +25,12 @@ import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
 import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand;
 import io.nosqlbench.nb.api.components.events.ParamChange;
 import io.nosqlbench.scenarios.simframe.SimFrameUtils;
+import io.nosqlbench.scenarios.simframe.capture.JournalView;
 import io.nosqlbench.scenarios.simframe.capture.SimFrameCapture;
 import io.nosqlbench.scenarios.simframe.capture.SimFrameJournal;
 import io.nosqlbench.scenarios.simframe.capture.SimFrameValueData;
 import io.nosqlbench.scenarios.simframe.optimizers.CMD_optimize;
+import io.nosqlbench.scenarios.simframe.planning.HoldAndSample;
 import io.nosqlbench.scenarios.simframe.planning.SimFrame;
 import io.nosqlbench.scenarios.simframe.planning.SimFrameFunction;
 import org.apache.commons.math4.legacy.exception.MathIllegalStateException;
@@ -39,6 +41,7 @@ import org.apache.logging.log4j.Logger;
 
 import java.io.PrintWriter;
 import java.io.Reader;
+import java.util.Comparator;
 
 public class CMD_findmax extends NBBaseCommand {
     private final static Logger logger = LogManager.getLogger(CMD_optimize.class);
@@ -63,45 +66,23 @@ public class CMD_findmax extends NBBaseCommand {
             findmaxConfig.rate_base(),    // initial
             findmaxConfig.sample_max(),   // max
             rate -> flywheel.onEvent(ParamChange.of(new CycleRateSpec(
-                findmaxConfig.rate_base() + findmaxConfig.rate_step(),
+                rate,
                 1.1d,
                 SimRateSpec.Verb.restart)))
         );
 
         SimFrameCapture capture = new SimFrameValueData(flywheel);
         SimFrameFunction frameFunction = new FindmaxFrameFunction(controller, findmaxConfig, flywheel, capture, journal, model);
-        FindmaxAnalyzer analyzer = new FindmaxAnalyzer(frameFunction, model);
-        FindmaxFrameParams result = analyzer.analyze();
-        stdout.println("result:" + result);
+        double[] initialPoint = {findmaxConfig.rate_base()};
+        double result = frameFunction.value(initialPoint);
+        while (result != 0.0d) {
+            result = ((FindmaxFrameFunction) frameFunction).nextStep();
+        }
 
-        SimFrame<FindmaxFrameParams> best = journal.bestRun();
+        SimFrame<FindmaxFrameParams> best = ((FindmaxFrameFunction)frameFunction).journal().bestRun();
         stdout.println("bestrun:\n" + best);
         return best.params();
     }
 
-    private class FindmaxAnalyzer {
-        private final SimFrameFunction frameFunction;
-        private final FindmaxParamModel model;
-        public FindmaxAnalyzer(SimFrameFunction frameFunction, FindmaxParamModel model) {
-            this.frameFunction = frameFunction;
-            this.model = model;
-        }
 
-        public FindmaxFrameParams analyze() {
-            FindmaxFrameParams frameParams = new FindmaxFrameParams(model, null);
-
-//            while (frameParams != null) {
-//                applyParams(frameParams,flywheel);
-//                capture.startWindow();
-//                capture.awaitSteadyState();
-//                capture.stopWindow();
-//                journal.record(frameParams, capture.last());
-//                stdout.println(capture.last());
-//                stdout.println("-".repeat(40));
-//                frameParams = nextStep(journal);
-//            }
-//            return journal.bestRun().params();
-            return null;
-        }
-    }
 }

nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/findmax/FindmaxConfig.java

@@ -18,26 +18,78 @@ package io.nosqlbench.scenarios.simframe.optimizers.findmax;
 
 import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams;
 
-public record FindmaxConfig(
-    double sample_time_ms,
-    double sample_max,
-    double sample_incr,
-    double rate_base,
-    double rate_step,
-    double rate_incr,
-    double average_of,
-    double min_settling_ms
-) {
+public class FindmaxConfig {
+    private double sample_time_ms;
+    private double sample_max;
+    private double rate_base;
+    private double rate_step;
+    private double rate_incr;
+    private double sample_incr;
+    private long min_settling_ms;
+
+    public double sample_time_ms() {
+        return sample_time_ms;
+    }
+
+    public double sample_max() {
+        return sample_max;
+    }
+
+    public double rate_base() {
+        return rate_base;
+    }
+
+    public double rate_step() {
+        return rate_step;
+    }
+
+    public double rate_incr() {
+        return rate_incr;
+    }
+
+    public double sample_incr() {
+        return sample_incr;
+    }
+
+    public long min_settling_ms() {
+        return min_settling_ms;
+    }
+
+    public void setSample_time_ms(double sample_time_ms) {
+        this.sample_time_ms = sample_time_ms;
+    }
+
+    public void setSample_max(double sample_max) {
+        this.sample_max = sample_max;
+    }
+
+    public void setRate_base(double rate_base) {
+        this.rate_base = rate_base;
+    }
+
+    public void setRate_step(double rate_step) {
+        this.rate_step = rate_step;
+    }
+
+    public void setSample_incr(double sample_incr) {
+        this.sample_incr = sample_incr;
+    }
+
+    public void setRate_incr(double rate_incr) {
+        this.rate_incr = rate_incr;
+    }
+
+    public void setMin_settling_ms(long min_settling_ms) {
+        this.min_settling_ms = min_settling_ms;
+    }
+
     public FindmaxConfig(NBCommandParams params) {
-        this(
-            params.maybeGet("sample_time_ms").map(Double::parseDouble).orElse(4000d),
-            params.maybeGet("sample_max").map(Double::parseDouble).orElse(10000d),
-            params.maybeGet("sample_incr").map(Double::parseDouble).orElse(1.2d),
-            params.maybeGet("rate_base").map(Double::parseDouble).orElse(0d),
-            params.maybeGet("rate_step").map(Double::parseDouble).orElse(100d),
-            params.maybeGet("rate_incr").map(Double::parseDouble).orElse(2d),
-            params.maybeGet("average_of").map(Double::parseDouble).orElse(2d),
-            params.maybeGet("min_settling_ms").map(Double::parseDouble).orElse(4000d)
-        );
+        params.maybeGet("sample_time_ms").map(Double::parseDouble).orElse(4000d);
+        params.maybeGet("sample_max").map(Double::parseDouble).orElse(10000d);
+        params.maybeGet("rate_base").map(Double::parseDouble).orElse(10d);
+        params.maybeGet("rate_step").map(Double::parseDouble).orElse(100d);
+        params.maybeGet("rate_incr").map(Double::parseDouble).orElse(2d);
+        params.maybeGet("sample_incr").map(Double::parseDouble).orElse(1.2d);
+        params.maybeGet("min_settling_ms").map(Long::parseLong).orElse(4000L);
     }
 }

nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/findmax/FindmaxFrameFunction.java

@@ -19,12 +19,17 @@ package io.nosqlbench.scenarios.simframe.optimizers.findmax;
 import io.nosqlbench.engine.api.activityapi.core.Activity;
 import io.nosqlbench.engine.api.activityapi.core.RunState;
 import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController;
+import io.nosqlbench.scenarios.simframe.capture.JournalView;
 import io.nosqlbench.scenarios.simframe.capture.SimFrameCapture;
 import io.nosqlbench.scenarios.simframe.capture.SimFrameJournal;
 import io.nosqlbench.scenarios.simframe.planning.HoldAndSample;
+import io.nosqlbench.scenarios.simframe.planning.SimFrame;
 import io.nosqlbench.scenarios.simframe.planning.SimFrameFunction;
 
 import java.io.PrintWriter;
+import java.util.Comparator;
+
+import static io.nosqlbench.virtdata.core.bindings.VirtDataLibrary.logger;
 
 public class FindmaxFrameFunction implements SimFrameFunction {
 
@@ -71,4 +76,47 @@ public class FindmaxFrameFunction implements SimFrameFunction {
         }
         return journal.last().value();
     }
+
+    public double nextStep() {
+        double newRate = 0.0d;
+        SimFrame<FindmaxFrameParams> last = journal.last();
+        SimFrame<FindmaxFrameParams> best = journal.bestRun();
+        if (best.index() == last.index()) { // got better consecutively
+            newRate = last.params().paramValues()[0] + settings.rate_step();
+            settings.setRate_step(settings.rate_step() * settings.rate_incr());
+        } else if (best.index() == last.index() - 1) {
+            // got worse consecutively, this may be collapsed out since the general case below covers it (test first)
+            if (((last.params().paramValues()[0] + settings.rate_step()) -
+                (best.params().paramValues()[0] + settings.rate_step())) <= settings.rate_step()) {
+                logger.info("could not divide search space further, stop condition met");
+                return 0;
+            } else {
+                newRate = best.params().paramValues()[0] + settings.rate_step();
+                settings.setSample_time_ms(settings.sample_time_ms() * settings.sample_incr());
+                settings.setMin_settling_ms(settings.min_settling_ms() * 4);
+            }
+        } else { // any other case
+            // find next frame with higher rate but lower value, the closest one by rate
+            SimFrame<FindmaxFrameParams> nextWorseFrameWithHigherRate = journal.frames().stream()
+                .filter(f -> f.value() < best.value())
+                .filter(f -> f.params().paramValues()[0] + settings.rate_step() > (best.params().paramValues()[0] + settings.rate_step()))
+                .min(Comparator.comparingDouble(f -> f.params().paramValues()[0] + settings.rate_step()))
+                .orElseThrow(() -> new RuntimeException("inconsistent samples"));
+            if ((nextWorseFrameWithHigherRate.params().paramValues()[0] + settings.rate_step() -
+                best.params().paramValues()[0] + settings.rate_step()) > settings.rate_step()) {
+                newRate = best.params().paramValues()[0] + settings.rate_step();
+                settings.setSample_time_ms(settings.sample_time_ms() * settings.sample_incr());
+                settings.setMin_settling_ms(settings.min_settling_ms() * 2);
+            } else {
+                logger.info("could not divide search space further, stop condition met");
+                return 0.0d;
+            }
+        }
+        double[] point = {newRate};
+        return value(point);
+    }
+
+    public SimFrameJournal<FindmaxFrameParams>  journal() {
+        return journal;
+    }
 }