Profiler.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Text;
using System.Xml;
using Waher.Runtime.Profiling.Events;
using Waher.Runtime.Profiling.Export;
 
namespace Waher.Runtime.Profiling
{
    public enum TimeUnit
    {
        DynamicPerEvent,
 
        DynamicPerThread,
 
        DynamicPerProfiling,
 
        MicroSeconds,
 
        MilliSeconds,
 
        Seconds,
 
        Minutes,
 
        Hours,
 
        Days
    }
 
    public class Profiler
    {
        private readonly SortedDictionary<string, int> exceptionOrdinals = new SortedDictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
        private readonly SortedDictionary<string, int> eventOrdinals = new SortedDictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
        private readonly List<ProfilerThread> threads = new List<ProfilerThread>();
        private readonly SortedDictionary<int, object> notes = new SortedDictionary<int, object>();
        private readonly Dictionary<string, ProfilerThread> threadsByName = new Dictionary<string, ProfilerThread>();
        private readonly ProfilerThread mainThread;
        private readonly Stopwatch watch;
        private DateTime started = DateTime.MinValue;
        private double timeScale = 1;
        private int threadOrder = 0;
 
        public Profiler()
            : this("Main", ProfilerThreadType.Sequential)
        {
        }
 
        public Profiler(string Name)
            : this(Name, ProfilerThreadType.Sequential)
        {
        }
 
        public Profiler(ProfilerThreadType Type)
            : this("Main", Type)
        {
        }
 
        public Profiler(string Name, ProfilerThreadType Type)
        {
            this.mainThread = this.CreateThread(Name, Type);
            this.watch = new Stopwatch();
        }
 
        public ProfilerThread MainThread => this.mainThread;
 
        public ProfilerThread CreateThread(string Name, ProfilerThreadType Type)
        {
            lock (this.threads)
            {
                ProfilerThread Result = new ProfilerThread(Name, ++this.threadOrder, Type, this);
                this.threads.Add(Result);
                this.threadsByName[Name] = Result;
                return Result;
            }
        }
 
        public ProfilerThread GetThread(string Name, ProfilerThreadType Type)
        {
            lock (this.threads)
            {
                if (this.threadsByName.TryGetValue(Name, out ProfilerThread Result))
                    return Result;
 
                Result = new ProfilerThread(Name, ++this.threadOrder, Type, this);
                this.threads.Add(Result);
                this.threadsByName[Name] = Result;
                return Result;
            }
        }
 
        internal ProfilerThread CreateThread(string Name, ProfilerThreadType Type, ProfilerThread Parent)
        {
            lock (this.threads)
            {
                ProfilerThread Result = new ProfilerThread(Name, ++this.threadOrder, Type, Parent);
                this.threads.Add(Result);
                this.threadsByName[Name] = Result;
                return Result;
            }
        }
 
        internal ProfilerThread GetThread(string Name, ProfilerThreadType Type, ProfilerThread Parent)
        {
            lock (this.threads)
            {
                if (this.threadsByName.TryGetValue(Name, out ProfilerThread Result))
                    return Result;
 
                Result = new ProfilerThread(Name, ++this.threadOrder, Type, Parent);
                this.threads.Add(Result);
                this.threadsByName[Name] = Result;
                return Result;
            }
        }
 
        public void Start()
        {
            this.started = DateTime.Now;
            this.watch.Start();
            this.mainThread.Start();
        }
 
        public void Stop()
        {
            this.mainThread.Stop();
            this.watch.Stop();
        }
 
        public long ElapsedTicks => this.watch.ElapsedTicks;
 
        public double ElapsedSeconds => this.ToSeconds(this.ElapsedTicks);
 
        public DateTime Started => this.started;
 
        public long GetTicks(DateTime Timepoint)
        {
            double Seconds = (Timepoint - this.started).TotalSeconds;
            return (long)(Seconds * Stopwatch.Frequency + 0.5);
        }
 
        public void NewState(string State)
        {
            this.mainThread.NewState(State);
        }
 
        public void NewSample(double Sample)
        {
            this.mainThread.NewSample(Sample);
        }
 
        public void Idle()
        {
            this.mainThread.Idle();
        }
 
        public void High()
        {
            this.mainThread.High();
        }
 
        public void Low()
        {
            this.mainThread.Low();
        }
 
        public void Interval(DateTime From, DateTime To, string Label)
        {
            this.mainThread.Interval(this.GetTicks(From), this.GetTicks(To), Label);
        }
 
        public void Interval(long From, long To, string Label)
        {
            this.mainThread.Interval(From, To, Label);
        }
 
        public void Event(string Name)
        {
            this.mainThread.Event(Name);
        }
 
        public void Event(string Name, string Label)
        {
            this.mainThread.Event(Name, Label);
        }
 
        public void Exception(System.Exception Exception)
        {
            this.mainThread.Exception(Exception);
        }
 
        public void Exception(System.Exception Exception, string Label)
        {
            this.mainThread.Exception(Exception, Label);
        }
 
        public double ToSeconds(long Ticks)
        {
            return ((double)Ticks) / Stopwatch.Frequency;
        }
 
        public KeyValuePair<double, string> ToTime(long Ticks, ProfilerThread Thread, TimeUnit TimeUnit)
        {
            double Amount = this.ToSeconds(Ticks);
            double Reference;
 
            switch (TimeUnit)
            {
                case TimeUnit.MicroSeconds:
                    return new KeyValuePair<double, string>(Amount * 1e6, "μs");
 
                case TimeUnit.MilliSeconds:
                    return new KeyValuePair<double, string>(Amount * 1e3, "ms");
 
                case TimeUnit.Seconds:
                    return new KeyValuePair<double, string>(Amount, "s");
 
                case TimeUnit.Minutes:
                    return new KeyValuePair<double, string>(Amount / 60, "min");
 
                case TimeUnit.Hours:
                    return new KeyValuePair<double, string>(Amount / (60 * 60), "h");
 
                case TimeUnit.Days:
                    return new KeyValuePair<double, string>(Amount / (24 * 60 * 60), "d");
 
                case TimeUnit.DynamicPerProfiling:
                    Reference = this.ToSeconds(this.MainThread.StoppedAt ?? this.ElapsedTicks);
                    break;
 
                case TimeUnit.DynamicPerThread:
                    Reference = this.ToSeconds(Thread.StoppedAt ?? this.ElapsedTicks);
                    break;
 
                case TimeUnit.DynamicPerEvent:
                default:
                    Reference = Amount;
                    break;
            }
 
            Reference *= this.timeScale;
 
            if (Reference < 1)
            {
                Amount *= 1e3;
                Reference *= 1e3;
                if (Reference < 1)
                {
                    Amount *= 1e3;
                    return new KeyValuePair<double, string>(Amount, "μs");
                }
                else
                    return new KeyValuePair<double, string>(Amount, "ms");
            }
            else if (Reference > 100)
            {
                Amount /= 60;
                Reference /= 60;
                if (Reference > 100)
                {
                    Amount /= 60;
                    Reference /= 60;
                    if (Reference > 100)
                    {
                        Amount /= 24;
                        return new KeyValuePair<double, string>(Amount, "d");
                    }
                    else
                        return new KeyValuePair<double, string>(Amount, "h");
                }
                else
                    return new KeyValuePair<double, string>(Amount, "min");
            }
            else
                return new KeyValuePair<double, string>(Amount, "s");
        }
 
        public string ToTimeStr(long Ticks, ProfilerThread Thread, TimeUnit TimeUnit, int NrDecimals)
        {
            KeyValuePair<double, string> Time = this.ToTime(Ticks, Thread, TimeUnit);
            return Time.Key.ToString("F" + NrDecimals.ToString()) + " " + Time.Value;
        }
 
        public string ExportXml(TimeUnit TimeUnit)
        {
            StringBuilder sb = new StringBuilder();
            XmlWriterSettings Settings = new XmlWriterSettings()
            {
                Indent = true,
                IndentChars = "\t",
                NewLineChars = "\r\n",
                NewLineHandling = NewLineHandling.Replace,
                NewLineOnAttributes = false,
                OmitXmlDeclaration = true
            };
 
            using (XmlWriter Output = XmlWriter.Create(sb, Settings))
            {
                this.ExportXml(Output, TimeUnit);
            }
 
            return sb.ToString();
        }
 
        public void ExportXml(XmlWriter Output, TimeUnit TimeUnit)
        {
            Output.WriteStartElement("Profiler", "http://waher.se/schema/Profiler.xsd");
            Output.WriteAttributeString("ticksPerSecond", Stopwatch.Frequency.ToString());
            Output.WriteAttributeString("timePerTick", this.ToTimeStr(1, this.mainThread, TimeUnit.DynamicPerEvent, 7));
 
            ProfilerThread[] Threads;
 
            lock (this.threads)
            {
                Threads = this.threads.ToArray();
            }
 
            foreach (ProfilerThread Thread in Threads)
            {
                if (Thread.Parent is null)
                    Thread.ExportXml(Output, TimeUnit);
            }
 
            Output.WriteEndElement();
        }
 
        public string ExportPlantUml(TimeUnit TimeUnit)
        {
            StringBuilder sb = new StringBuilder();
            this.ExportPlantUml(sb, TimeUnit);
            return sb.ToString();
        }
 
        public void ExportPlantUml(StringBuilder Output, TimeUnit TimeUnit)
        {
            this.ExportPlantUml(Output, TimeUnit, 1000);
        }
 
        public void ExportPlantUml(StringBuilder Output, TimeUnit TimeUnit, int GoalWidth)
        {
            switch (TimeUnit)
            {
                case TimeUnit.DynamicPerEvent:
                case TimeUnit.DynamicPerThread:
                    throw new InvalidOperationException("Diagram requires the same time base to be used through-out.");
            }
 
            Output.AppendLine("@startuml");
 
            ProfilerThread[] Threads;
 
            lock (this.threads)
            {
                Threads = this.threads.ToArray();
            }
 
            foreach (ProfilerThread Thread in Threads)
            {
                if (Thread.Parent is null)
                    Thread.ExportPlantUmlDescription(Output, TimeUnit);
            }
 
            lock (this.eventOrdinals)
            {
                foreach (KeyValuePair<string, int> P in this.eventOrdinals)
                {
                    Output.Append("concise \"");
                    Output.Append(P.Key);
                    Output.Append("\" as E");
                    Output.AppendLine(P.Value.ToString());
                }
            }
 
            lock (this.exceptionOrdinals)
            {
                foreach (KeyValuePair<string, int> P in this.exceptionOrdinals)
                {
                    Output.Append("concise \"");
                    Output.Append(P.Key);
                    Output.Append("\" as X");
                    Output.AppendLine(P.Value.ToString());
                }
            }
 
            double TimeSpan;
            double StepSize;
            int NrSteps;
 
            do
            {
                KeyValuePair<double, string> TotalTime = this.ToTime(this.mainThread.StoppedAt ?? this.ElapsedTicks, this.mainThread, TimeUnit);
 
                TimeSpan = TotalTime.Key;
                StepSize = Math.Pow(10, Math.Round(Math.Log10(TimeSpan / 10)));
                NrSteps = (int)Math.Floor(TimeSpan / StepSize);
 
                if (NrSteps >= 50)
                    StepSize *= 5;
                else if (NrSteps >= 25)
                    StepSize *= 2.5;
                else if (NrSteps >= 20)
                    StepSize *= 2;
                else if (NrSteps <= 2)
                    StepSize /= 5;
                else if (NrSteps <= 4)
                    StepSize /= 2.5;
                else if (NrSteps <= 5)
                    StepSize /= 2;
 
                if (StepSize < 1)
                    this.timeScale *= 1e-3;
            }
            while (StepSize < 1 && StepSize > 0);
 
            StepSize = Math.Floor(StepSize);
            NrSteps = (int)Math.Floor(TimeSpan / StepSize);
            int PixelsPerStep = NrSteps > 0 ? GoalWidth / NrSteps : 0;
 
            Output.Append("scale ");
            Output.Append(StepSize.ToString("F0"));
            Output.Append(" as ");
            Output.Append(PixelsPerStep);
            Output.AppendLine(" pixels");
 
            PlantUmlStates States = new PlantUmlStates(TimeUnit);
 
            foreach (ProfilerThread Thread in Threads)
            {
                if (Thread.Parent is null)
                    Thread.ExportPlantUmlEvents(States);
            }
 
            foreach (KeyValuePair<long, StringBuilder> P in States.ByTime)
            {
                KeyValuePair<double, string> Time = this.ToTime(P.Key, null, TimeUnit);
                Output.Append('@');
                Output.AppendLine(Time.Key.ToString("F7").Replace(CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator, "."));
                Output.Append(P.Value.ToString());
            }
 
            Output.Append(States.Summary.ToString());
            Output.AppendLine("@enduml");
        }
 
        public int GetEventOrdinal(string Event)
        {
            return GetOrdinal(this.eventOrdinals, Event);
        }
 
        private static int GetOrdinal(SortedDictionary<string, int> Ordinals, string Key)
        {
            lock (Ordinals)
            {
                if (Ordinals.TryGetValue(Key, out int Ordinal))
                    return Ordinal;
 
                Ordinal = Ordinals.Count;
                Ordinals[Key] = Ordinal;
 
                return Ordinal;
            }
        }
 
        public int GetExceptionOrdinal(System.Exception Exception)
        {
            return GetOrdinal(this.exceptionOrdinals, Exception.GetType().FullName);
        }
 
        public int AddNote(object Note)
        {
            int Result;
 
            lock (this.notes)
            {
                Result = this.notes.Count + 1;
                this.notes[Result] = Note;
            }
 
            return Result;
        }
 
        public int NoteCount
        {
            get
            {
                lock (this.notes)
                {
                    return this.notes.Count;
                }
            }
        }
 
        public bool TryGetNote(int Index, out object Note)
        {
            lock (this.notes)
            {
                return this.notes.TryGetValue(Index, out Note);
            }
        }
    }
}