ProfilerThread.cs

using System;
using System.Collections.Generic;
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 ProfilerThreadType
    {
        Sequential,
 
        StateMachine,
 
        Accumulating,
 
        Binary,
 
        Analog
    }
 
    public class ProfilerThread
    {
        private readonly List<ProfilerThread> subThreads = new List<ProfilerThread>();
        private readonly List<ProfilerEvent> events = new List<ProfilerEvent>();
        private readonly string name;
        private readonly int order;
        private readonly ProfilerThreadType type;
        private readonly Profiler profiler;
        private readonly ProfilerThread parent;
        private long? startedAt = null;
        private long? stoppedAt = null;
 
        public ProfilerThread(string Name, int Order, ProfilerThreadType Type, Profiler Profiler)
        {
            this.name = Name;
            this.order = Order;
            this.type = Type;
            this.profiler = Profiler;
            this.parent = null;
        }
 
        public ProfilerThread(string Name, int Order, ProfilerThreadType Type, ProfilerThread Parent)
        {
            this.name = Name;
            this.order = Order;
            this.type = Type;
            this.parent = Parent;
            this.profiler = this.parent.Profiler;
        }
 
        public string Name => this.name;
 
        public int Order => this.order;
 
        public ProfilerThreadType Type => this.type;
 
        public Profiler Profiler => this.profiler;
 
        public ProfilerThread Parent => this.parent;
 
        public long? StartedAt => this.startedAt;
 
        public long? StoppedAt => this.stoppedAt;
 
        public ProfilerThread CreateSubThread(string Name, ProfilerThreadType Type)
        {
            ProfilerThread Result = this.profiler.CreateThread(Name, Type, this);
            this.subThreads.Add(Result);
            return Result;
        }
 
        public void NewState(string State)
        {
            this.events.Add(new NewState(this.profiler.ElapsedTicks, State, this));
        }
 
        public void NewSample(double Sample)
        {
            this.events.Add(new NewSample(this.profiler.ElapsedTicks, Sample, this));
        }
 
        public void Idle()
        {
            this.events.Add(new Idle(this.profiler.ElapsedTicks, this));
        }
 
        public void High()
        {
            this.NewState("high");
        }
 
        public void Low()
        {
            this.NewState("low");
        }
 
        public void Interval(DateTime From, DateTime To, string Label)
        {
            this.events.Add(new Interval(this.profiler.GetTicks(From), this.profiler.GetTicks(To), Label, this));
        }
 
        public void Interval(long From, long To, string Label)
        {
            this.events.Add(new Interval(From, To, Label, this));
        }
 
        public void Event(string Name)
        {
            this.events.Add(new Event(this.profiler.ElapsedTicks, Name, this));
        }
 
        public void Event(string Name, string Label)
        {
            this.events.Add(new Event(this.profiler.ElapsedTicks, Name, Label, this));
        }
 
        public void Exception(System.Exception Exception)
        {
            this.events.Add(new Events.Exception(this.profiler.ElapsedTicks, Exception, this));
        }
 
        public void Exception(System.Exception Exception, string Label)
        {
            this.events.Add(new Events.Exception(this.profiler.ElapsedTicks, Exception, Label, this));
        }
 
        public void Start()
        {
            long Ticks = this.profiler.ElapsedTicks;
            this.startedAt = Ticks;
            this.events.Add(new Start(Ticks, this));
        }
 
        public void Stop()
        {
            long Ticks = this.profiler.ElapsedTicks;
            this.stoppedAt = Ticks;
            this.events.Add(new Stop(Ticks, this));
        }
 
        public void ExportXml(XmlWriter Output, TimeUnit TimeUnit)
        {
            Output.WriteStartElement("Thread");
            Output.WriteAttributeString("name", this.name);
            Output.WriteAttributeString("type", this.type.ToString());
 
            Output.WriteStartElement("Events");
 
            ProfilerEvent Prev = null;
 
            foreach (ProfilerEvent Event in this.events)
            {
                Event.ExportXml(Output, Prev, TimeUnit);
                Prev = Event;
            }
 
            Output.WriteEndElement();
 
            foreach (ProfilerThread Thread in this.subThreads)
                Thread.ExportXml(Output, TimeUnit);
 
            Output.WriteEndElement();
        }
 
        public void ExportPlantUmlDescription(StringBuilder Output, TimeUnit TimeUnit)
        {
            switch (this.type)
            {
                case ProfilerThreadType.StateMachine:
                    Output.Append("robust \"");
                    break;
 
                case ProfilerThreadType.Binary:
                    Output.Append("binary \"");
                    break;
 
                case ProfilerThreadType.Analog:
                    Output.Append("analog \"");
                    break;
 
                case ProfilerThreadType.Sequential:
                case ProfilerThreadType.Accumulating:
                default:
                    Output.Append("concise \"");
                    break;
            }
 
            Output.Append(this.name);
            Output.Append("\" as T");
            Output.AppendLine(this.order.ToString());
 
            if (this.type == ProfilerThreadType.Accumulating)
            {
                Accumulator Accumulator = new Accumulator(this);
                ProfilerEvent[] Events = this.events.ToArray();
                this.events.Clear();
 
                foreach (ProfilerEvent Event in Events)
                    Event.Accumulate(Accumulator);
 
                Accumulator.Report(this.events);
            }
 
            foreach (ProfilerEvent Event in this.events)
                Event.ExportPlantUmlPreparation();
 
            foreach (ProfilerThread Thread in this.subThreads)
                Thread.ExportPlantUmlDescription(Output, TimeUnit);
        }
 
        public string Key => "T" + this.order.ToString();
 
        public void ExportPlantUmlEvents(PlantUmlStates States)
        {
            foreach (ProfilerEvent Event in this.events)
                Event.ExportPlantUml(States);
 
            foreach (ProfilerThread Thread in this.subThreads)
                Thread.ExportPlantUmlEvents(States);
            
            if (this.startedAt.HasValue && this.stoppedAt.HasValue)
            {
                StringBuilder Output = States.Summary;
                long Ticks = this.stoppedAt.Value - this.startedAt.Value;
                string ElapsedStr = this.profiler.ToTimeStr(Ticks, this, States.TimeUnit, 3);
                KeyValuePair<double, string> Time;
 
                Output.Append(this.Key);
                Output.Append('@');
                    
                Time = this.profiler.ToTime(this.startedAt.Value, this, States.TimeUnit);
                Output.Append(Time.Key.ToString("F0").Replace(CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator, "."));
 
                Output.Append(" <-> @");
 
                Time = this.profiler.ToTime(this.stoppedAt.Value, this, States.TimeUnit);
                Output.Append(Time.Key.ToString("F0").Replace(CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator, "."));
 
                Output.Append(" : ");
                Output.AppendLine(ElapsedStr);
            }
        }
 
        public KeyValuePair<double, string> ToTime(long Ticks, TimeUnit TimeUnit)
        {
            return this.profiler.ToTime(Ticks, this, TimeUnit);
        }
 
        public string ToTimeStr(long Ticks, TimeUnit TimeUnit)
        {
            return this.profiler.ToTimeStr(Ticks, this, TimeUnit, 7);
        }
 
    }
}