Benchmarker2D.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Text;
 
namespace Waher.Runtime.Profiling
{
    public class Benchmarker2D : IBenchmarker
    {
        private readonly SortedDictionary<string, bool> tests = new SortedDictionary<string, bool>();
        private readonly SortedDictionary<long, bool> complexities = new SortedDictionary<long, bool>();
        private readonly Dictionary<string, Dictionary<long, long>> ticks = new Dictionary<string, Dictionary<long, long>>();
        private readonly object syncObject = new object();
        private readonly Stopwatch watch;
 
        public Benchmarker2D()
        {
            this.watch = new Stopwatch();
            this.watch.Start();
        }
 
        public string[] Tests
        {
            get
            {
                lock (this.syncObject)
                {
                    return this.GetTestsLocked();
                }
            }
        }
 
        private string[] GetTestsLocked()
        {
            string[] Result = new string[this.tests.Count];
            this.tests.Keys.CopyTo(Result, 0);
            return Result;
        }
 
        public long[] Complexities
        {
            get
            {
                lock (this.syncObject)
                {
                    return this.GetComplexitiesLocked();
                }
            }
        }
 
        private long[] GetComplexitiesLocked()
        {
            long[] Result = new long[this.complexities.Count];
            this.complexities.Keys.CopyTo(Result, 0);
            return Result;
        }
 
        public double?[,] Ticks => this.GetScaledTicks(1);
 
        public double?[,] Minutes => this.GetScaledTicks(1.0 / (Stopwatch.Frequency * 60.0));
 
        public double?[,] Seconds => this.GetScaledTicks(1.0 / Stopwatch.Frequency);
 
        public double?[,] Milliseconds => this.GetScaledTicks(1000.0 / Stopwatch.Frequency);
 
        public double?[,] Microseconds => this.GetScaledTicks(1000000.0 / Stopwatch.Frequency);
 
        private double?[,] GetScaledTicks(double Scale)
        {
            lock (this.syncObject)
            {
                return this.GetScaledTicksLocked(Scale);
            }
        }
 
        private double?[,] GetScaledTicksLocked(double Scale)
        {
            double?[,] Result = new double?[this.tests.Count, this.complexities.Count];
            int i, j;
 
            i = 0;
            foreach (string Name in this.tests.Keys)
            {
                j = 0;
                foreach (long Complexity in this.complexities.Keys)
                {
                    if (this.ticks.TryGetValue(Name, out Dictionary<long, long> Complexities) &&
                        Complexities.TryGetValue(Complexity, out long Ticks))
                    {
                        Result[i, j] = Ticks * Scale;
                    }
                    else
                        Result[i, j] = null;
 
                    j++;
                }
 
                i++;
            }
 
            return Result;
        }
 
        public string GetResultScriptTicks() => this.GetResultScript(1);
 
        public string GetResultScriptSeconds() => this.GetResultScript(1.0 / Stopwatch.Frequency);
 
        public string GetResultScriptMilliseconds() => this.GetResultScript(1000.0 / Stopwatch.Frequency);
 
        public string GetResultScriptMicroseconds() => this.GetResultScript(1000000.0 / Stopwatch.Frequency);
 
        private string GetResultScript(double Scale)
        {
            StringBuilder sb = new StringBuilder();
            string[] Names;
            long[] ComplexitiesN;
            double?[,] Values;
            double? d;
            int i, j, c, N;
 
            lock (this.syncObject)
            {
                Names = this.GetTestsLocked();
                ComplexitiesN = this.GetComplexitiesLocked();
                Values = this.GetScaledTicksLocked(Scale);
            }
 
            c = Names.Length;
            N = ComplexitiesN.Length;
 
            sb.Append("[[\"N\\\\Test\"");
            foreach (string Name in Names)
            {
                sb.Append(",\"");
                sb.Append(Name.Replace("\"", "\\\""));
                sb.Append('"');
            }
            sb.Append(']');
 
            for (j = 0; j < N; j++)
            {
                sb.Append(",\r\n [");
                sb.Append(ComplexitiesN[j].ToString());
 
                for (i = 0; i < c; i++)
                {
                    sb.Append(',');
 
                    d = Values[i, j];
                    if (d.HasValue)
                        sb.Append(d.Value.ToString(CultureInfo.InvariantCulture));
                    else
                        sb.Append("null");
                }
 
                sb.Append(']');
            }
 
            sb.Append(']');
 
            return sb.ToString();
        }
 
        public Benchmarking Start(string Name, long Complexity)
        {
            GC.GetTotalMemory(true);
 
            lock (this.syncObject)
            {
                if (!this.tests.ContainsKey(Name))
                    this.tests[Name] = true;
 
                if (!this.complexities.ContainsKey(Complexity))
                    this.complexities[Complexity] = true;
            }
 
            return new Benchmarking(this, Name, Complexity, 0, this.watch.ElapsedTicks);
        }
 
        public void Stop(string Name, long N, long M, long StartTicks)
        {
            long ElapsedTicks = this.watch.ElapsedTicks - StartTicks;
 
            lock (this.syncObject)
            {
                if (!this.ticks.TryGetValue(Name, out Dictionary<long, long> Complexities))
                {
                    Complexities = new Dictionary<long, long>();
                    this.ticks[Name] = Complexities;
                }
 
                Complexities[N] = ElapsedTicks;
            }
        }
 
        public bool Remove(string Name)
        {
            lock (this.syncObject)
            {
                this.ticks.Remove(Name);
                return this.tests.Remove(Name);
            }
        }
 
        public bool Remove(long N)
        {
            lock (this.syncObject)
            {
                foreach (Dictionary<long, long> Complexities in this.ticks.Values)
                    Complexities.Remove(N);
 
                return this.complexities.Remove(N);
            }
        }
 
        public void Dispose()
        {
            this.watch.Stop();
        }
    }
}