From a29537cda306b3acc0ddbe23a70b5eb4dc8444f2 Mon Sep 17 00:00:00 2001 From: oblonski <4sschroeder@gmail.com> Date: Sat, 5 Apr 2014 23:58:33 +0200 Subject: [PATCH] added analysis.toolbox.ComputationalLaboratory.java to make sensitivity studies --- .../toolbox/ComputationalLaboratory.java | 263 ++++++++++++++++++ 1 file changed, 263 insertions(+) create mode 100644 jsprit-analysis/src/main/java/jsprit/analysis/toolbox/ComputationalLaboratory.java diff --git a/jsprit-analysis/src/main/java/jsprit/analysis/toolbox/ComputationalLaboratory.java b/jsprit-analysis/src/main/java/jsprit/analysis/toolbox/ComputationalLaboratory.java new file mode 100644 index 00000000..6f998f8e --- /dev/null +++ b/jsprit-analysis/src/main/java/jsprit/analysis/toolbox/ComputationalLaboratory.java @@ -0,0 +1,263 @@ +package jsprit.analysis.toolbox; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; + +import jsprit.core.algorithm.VehicleRoutingAlgorithm; +import jsprit.core.algorithm.VehicleRoutingAlgorithmFactory; +import jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners.Priority; +import jsprit.core.problem.VehicleRoutingProblem; +import jsprit.core.problem.solution.VehicleRoutingProblemSolution; +import jsprit.core.util.BenchmarkInstance; +import jsprit.core.util.Solutions; + +import org.apache.log4j.Level; +import org.apache.log4j.Logger; + +public class ComputationalLaboratory { + + public abstract static interface Result { + + public abstract String getIndicatorName(); + + public abstract double getResult(); + } + + public abstract static interface Indicator { + + public abstract void calculationStarts(); + + public abstract void runStarts(VehicleRoutingAlgorithm vra); + + public abstract void runEnds(VehicleRoutingProblemSolution vrs); + + public abstract double getResult(); + + public abstract String getIndicatorName(); + + } + + public static class ResultContainer { + + private List results = new ArrayList(); + + private String instanceName; + + private String algorithmName; + + public ResultContainer(String instanceName, String algorithmName) { + this.instanceName = instanceName; + this.algorithmName = algorithmName; + } + + public void addResult(Result result){ + results.add(result); + } + + public List getResults() { + return results; + } + + public String getInstanceName() { return instanceName; } + + public String getAlgorithmName() { return algorithmName; } + + } + + public abstract static interface IndicatorFactory { + public abstract Indicator createIndicator(VehicleRoutingProblem vrp); + } + + public static interface ResultWriter { + public void writeResults(Collection results); + } + + private static class Algorithm { + + private String name; + + private VehicleRoutingAlgorithmFactory factory; + + public Algorithm(String name, VehicleRoutingAlgorithmFactory factory) { + super(); + this.name = name; + this.factory = factory; + } + + } + + private List benchmarkInstances = new ArrayList(); + + private int runs = 1; + + private Collection writers = new ArrayList(); + + private Collection results = new ArrayList(); + + private Collection indicatorFactories = new ArrayList(); + + private List algorithms = new ArrayList(); + + private int threads = Runtime.getRuntime().availableProcessors()+1; + + public ComputationalLaboratory() { + Logger.getRootLogger().setLevel(Level.ERROR); + } + + public void addResultWriter(ResultWriter writer){ + writers.add(writer); + } + + public void addAlgorithmFactory(String name, VehicleRoutingAlgorithmFactory factory){ + algorithms.add(new Algorithm(name,factory)); + } + + public void addIndicatorFactory(IndicatorFactory indicatorFactory){ + indicatorFactories.add(indicatorFactory); + } + + public void addInstance(String name, VehicleRoutingProblem problem){ + benchmarkInstances.add(new BenchmarkInstance(name,problem,null,null)); + } + + public void addInstance(BenchmarkInstance instance){ + benchmarkInstances.add(instance); + } + + public void addAllInstances(Collection instances){ + benchmarkInstances.addAll(instances); + } + + public void addInstance(String name, VehicleRoutingProblem problem, Double bestKnownResult, Double bestKnownVehicles){ + benchmarkInstances.add(new BenchmarkInstance(name,problem,bestKnownResult,bestKnownVehicles)); + } + + /** + * Sets nuOfRuns with same algorithm on same instance. + *

Default is 1 + * + * @param runs + */ + public void setNuOfRuns(int runs){ + this.runs = runs; + } + + public void run(){ + if(algorithms.isEmpty()){ + throw new IllegalStateException("no algorithm specified. at least one algorithm needs to be specified."); + } + if(benchmarkInstances.isEmpty()){ + throw new IllegalStateException("no instance specified. at least one instance needs to be specified."); + } + if(indicatorFactories.isEmpty()){ + throw new IllegalStateException("no indicator specified. at least one indicator needs to be specified."); + } + System.out.println("start benchmarking [nuAlgorithms="+algorithms.size()+"][nuInstances=" + benchmarkInstances.size() + "][runsPerInstance=" + runs + "]"); + double startTime = System.currentTimeMillis(); + ExecutorService executor = Executors.newFixedThreadPool(threads); + List> futures = new ArrayList>(); + for(final Algorithm algorithm : algorithms){ + for(final BenchmarkInstance p : benchmarkInstances){ + + Future futureResult = executor.submit(new Callable(){ + + @Override + public ResultContainer call() throws Exception { + return runAlgoAndGetResult(p, algorithm); + } + + }); + futures.add(futureResult); + } + } + try { + for(Future f : futures){ + results.add(f.get()); + } + } catch (InterruptedException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (ExecutionException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + executor.shutdown(); + write(results); + System.out.println("done [time="+(System.currentTimeMillis()-startTime)/1000 + "sec]"); + } + + public void setThreads(int threads) { + this.threads = threads; + } + + private ResultContainer runAlgoAndGetResult(BenchmarkInstance p, Algorithm algorithm) { + System.out.println("run " + algorithm.name + " on " + p.name); + List indicators = createIndicators(p.vrp); + informCalculationStarts(indicators); + for(int run=0;run indicators, String instanceName, String algorithmName) { + ResultContainer rc = new ResultContainer(instanceName, algorithmName); + for(final Indicator i : indicators) { + Result result = new Result(){ + + @Override + public String getIndicatorName() { + return i.getIndicatorName(); + } + + @Override + public double getResult() { + return i.getResult(); + } + + }; + rc.addResult(result); + } + return rc; + } + + private void informRunEnds(List indicators,VehicleRoutingProblemSolution best) { + for(Indicator i : indicators) i.runEnds(best); + } + + private void informRunStarts(List indicators,VehicleRoutingAlgorithm vra) { + for(Indicator i : indicators) i.runStarts(vra); + } + + private void informCalculationStarts(List indicators) { + for(Indicator i : indicators) i.calculationStarts(); + } + + private List createIndicators(VehicleRoutingProblem vrp) { + List indicators = new ArrayList(); + for(IndicatorFactory iFactory : indicatorFactories) indicators.add(iFactory.createIndicator(vrp)); + return indicators; + } + + private void write(Collection results) { + for(ResultWriter writer : writers){ + writer.writeResults(results); + } + } + +}