Benchmarker1D.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Text;
 
namespace Waher.Runtime.Profiling
{
    public class Benchmarker1D : IBenchmarker
    {
        private readonly SortedDictionary<string, long> tests = new SortedDictionary<string, long>();
        private readonly object syncObject = new object();
        private readonly Stopwatch watch;
 
        public Benchmarker1D()
        {
            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 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];
            int i;
 
            i = 0;
            foreach (string Name in this.tests.Keys)
            {
                if (this.tests.TryGetValue(Name, out long Ticks))
                    Result[i] = Ticks * Scale;
                else
                    Result[i] = null;
 
                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;
            double?[] Values;
            double? d;
            int i, c;
 
            lock (this.syncObject)
            {
                Names = this.GetTestsLocked();
                Values = this.GetScaledTicksLocked(Scale);
            }
 
            c = Names.Length;
 
            sb.Append('[');
 
            for (i = 0; i < c; i++)
            {
                if (i > 0)
                    sb.Append(",\r\n ");
                sb.Append("[\"");
                sb.Append(Names[i].Replace("\"", "\\\""));
                sb.Append("\",");
 
                d = Values[i];
                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)
        {
            GC.GetTotalMemory(true);
 
            lock (this.syncObject)
            {
                if (!this.tests.ContainsKey(Name))
                    this.tests[Name] = 0;
            }
 
            return new Benchmarking(this, Name, 0, 0, this.watch.ElapsedTicks);
        }
 
        public void Stop(string Name, long N, long M, long StartTicks)
        {
            long ElapsedTicks = this.watch.ElapsedTicks - StartTicks;
 
            lock (this.syncObject)
            {
                this.tests[Name] = ElapsedTicks;
            }
        }
 
        public bool Remove(string Name)
        {
            lock (this.syncObject)
            {
                return this.tests.Remove(Name);
            }
        }
 
        public void Dispose()
        {
            this.watch.Stop();
        }
    }
}