source: misc/tools/HeuristicLab.Benchmarks/HeuristicLab.Benchmarks/Problems.DataAnalysis.Symbolic/TreeDistanceAlgorithmPerformance.cs @ 16299

using BenchmarkDotNet.Attributes;
using HeuristicLab.Core;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Random;

namespace HeuristicLab.Benchmarks {
  //  [ClrJob]
  //[SimpleJob(RunStrategy.ColdStart, targetCount: 5)]
  [ShortRunJob]
  [MinColumn, MaxColumn, MeanColumn, MedianColumn]
  public class TreeDistancePerformance {

    private readonly IRandom random = new FastRandom(1234);
    private readonly Dataset dataset;
    private readonly ISymbolicDataAnalysisGrammar grammar;
    private ISymbolicExpressionTree[] trees;

    private readonly SymbolicExpressionTreeBottomUpSimilarityCalculator calculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator { MatchConstantValues = false, MatchVariableWeights = false };

    public TreeDistancePerformance() {
      dataset = Util.CreateRandomDataset(random, 1, 10);
      var typeCoherentGrammar = new TypeCoherentExpressionGrammar();
      typeCoherentGrammar.ConfigureAsDefaultRegressionGrammar();
      grammar = typeCoherentGrammar;
    }

    private const int Columns = 10;
    private const int minSize = 1;

    [Params(5000)]
    public int Trees { get; set; }

    [Params(100)]
    public int MaxLength { get; set; }

    [GlobalSetup]
    public void Setup() {
      trees = Util.CreateRandomTrees(random, dataset, grammar, Trees, minSize, MaxLength, 0, 0);
    }

    [Benchmark(Baseline = true)]
    public double BottomUpSimilarity() {
      var sim = 0d;
      var total = trees.Length * (trees.Length - 1) / 2;

      for (int i = 0; i < trees.Length - 1; ++i) {
        for (int j = i + 1; j < trees.Length; ++j) {
          sim += calculator.CalculateSimilarity(trees[i], trees[j]);
        }
      }
      return sim / total;
    }

    [Benchmark]
    public double HashBasedSimilarity() {
      var sim = 0d;

      var total = trees.Length * (trees.Length - 1) / 2;

      for (int i = 0; i < trees.Length - 1; ++i) {
        for (int j = i + 1; j < trees.Length; ++j) {
          sim += SymbolicExpressionTreeHash.ComputeSimilarity(trees[i], trees[j]);
        }
      }
      return sim / total;
    }

    [Benchmark]
    public double HashBasedSimilarityBatched() => SymbolicExpressionTreeHash.ComputeAverageSimilarity(trees);
  }
}