Add dummy optimization support

Author: BingTong0

dummy/README.md

@@ -4,6 +4,7 @@ You can execute the driver with three modes, and you should update the mode in t
 - CREATE_VALIDATION
 - VALIDATE_DATABASE
 - EXECUTE_BENCHMARK
+- OPTIMIZATION_RECOMMENDATION
 
 execute:
 ```
@@ -12,4 +13,25 @@ java -cp xxx.jar org.ldbcouncil.finbench.driver.driver.Driver -P example.propert
 
 debug:
 - add VM options `-P src/main/resources/example/example.properties`
-- run `Driver.main`
+- run `Driver.main`
+# Dummy Optimization Support
+
+`DummyDb` implements the optional FinBench `OptimizationSupport` capability. It samples the
+current JVM CPU and memory usage, runs a representative operation for resource profiling, and then
+executes bounded synthetic CPU/memory/duration loads for `OPTIMIZATION_RECOMMENDATION` mode tests.
+
+The dummy implementation caps each synthetic memory allocation at 16 MiB to keep local tests safe.
+
+Run the optimization recommendation example after building the dummy module:
+
+```bash
+mvn -pl dummy -am package -DskipTests
+cd dummy
+sh run_optimization_recommendation.sh
+```
+
+The script uses `src/main/resources/example/optimization_recommendation.properties` by default
+and writes `optimization-report.md` and `optimization-report.json` under the configured `results_dir`.
+You can tune
+`optimization.top_n`, `optimization.reduction_steps`, `optimization.profile_repetitions`, and
+`optimization.repetitions` in that properties file.

dummy/run_optimization_recommendation.sh

@@ -0,0 +1 @@
+java -cp target/dummy-0.2.0-alpha.jar org.ldbcouncil.finbench.driver.driver.Driver -P src/main/resources/example/optimization_recommendation.properties

dummy/src/main/java/org/ldbcouncil/finbench/impls/dummy/DummyDb.java

@@ -0,0 +1,84 @@
+package org.ldbcouncil.finbench.impls.dummy;
+
+import com.sun.management.OperatingSystemMXBean;
+import java.lang.management.ManagementFactory;
+import java.util.concurrent.TimeUnit;
+import org.ldbcouncil.finbench.driver.DbException;
+import org.ldbcouncil.finbench.driver.optimization.OptimizationSupport;
+import org.ldbcouncil.finbench.driver.optimization.OperationProfileSpec;
+import org.ldbcouncil.finbench.driver.optimization.ResourceSnapshot;
+import org.ldbcouncil.finbench.driver.optimization.SyntheticExecutionResult;
+import org.ldbcouncil.finbench.driver.optimization.SyntheticLoadSpec;
+
+/**
+ * Test implementation that models CPU, memory and duration inside the driver JVM.
+ */
+public class DummyOptimizationSupport implements OptimizationSupport {
+    private static final long MAX_TEST_ALLOCATION_BYTES = 16L * 1024 * 1024;
+
+    @Override
+    public ResourceSnapshot sampleResources() {
+        Runtime runtime = Runtime.getRuntime();
+        long usedMemory = runtime.totalMemory() - runtime.freeMemory();
+        double cpuCores = 0;
+        java.lang.management.OperatingSystemMXBean bean = ManagementFactory.getOperatingSystemMXBean();
+        if (bean instanceof OperatingSystemMXBean) {
+            OperatingSystemMXBean osBean = (OperatingSystemMXBean) bean;
+            double processLoad = osBean.getProcessCpuLoad();
+            if (processLoad >= 0) {
+                cpuCores = processLoad * osBean.getAvailableProcessors();
+            }
+        }
+        return new ResourceSnapshot(System.currentTimeMillis(), cpuCores, usedMemory);
+    }
+
+    @Override
+    public SyntheticExecutionResult executeRepresentativeOperation(OperationProfileSpec spec) throws DbException {
+        long durationMillis = Math.max(1, spec.expectedDurationMillis());
+        long memoryBytes = 1024L * Math.max(1, spec.operationName().length());
+        return executeSyntheticLoad(new SyntheticLoadSpec(spec.operationName(), 0.25, memoryBytes, durationMillis));
+    }
+
+    @Override
+    public SyntheticExecutionResult executeSyntheticLoad(SyntheticLoadSpec spec) throws DbException {
+        if (spec.targetDurationMillis() < 0 || spec.targetMemoryBytes() < 0 || spec.targetCpuCores() < 0) {
+            throw new DbException("Synthetic load values must be non-negative");
+        }
+
+        int allocationSize = (int) Math.min(spec.targetMemoryBytes(), MAX_TEST_ALLOCATION_BYTES);
+        byte[] allocation = allocationSize == 0 ? null : new byte[allocationSize];
+        if (allocation != null) {
+            for (int offset = 0; offset < allocation.length; offset += 4096) {
+                allocation[offset] = 1;
+            }
+        }
+
+        long start = System.nanoTime();
+        long deadline = start + TimeUnit.MILLISECONDS.toNanos(spec.targetDurationMillis());
+        if (spec.targetCpuCores() > 0) {
+            long value = 1;
+            while (System.nanoTime() < deadline) {
+                value = value * 31 + 17;
+            }
+            if (allocation != null) {
+                allocation[0] = (byte) value;
+            }
+        } else {
+            sleepUntil(deadline);
+        }
+        long durationMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
+        return new SyntheticExecutionResult(durationMillis, allocationSize);
+    }
+
+    private static void sleepUntil(long deadline) throws DbException {
+        while (System.nanoTime() < deadline) {
+            long remainingNanos = deadline - System.nanoTime();
+            try {
+                TimeUnit.NANOSECONDS.sleep(remainingNanos);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new DbException("Synthetic load interrupted", e);
+            }
+        }
+    }
+}