Accumulator.cs

using System.Collections.Generic;
using Waher.Runtime.Collections;
using Waher.Runtime.Profiling.Events;
 
namespace Waher.Runtime.Profiling.Export
{
    public class Accumulator
    {
        private readonly Dictionary<string, long> sumTicks = new Dictionary<string, long>();
        private readonly SortedDictionary<long, ChunkedList<ProfilerEvent>> timeline = new SortedDictionary<long, ChunkedList<ProfilerEvent>>();
        private readonly ChunkedList<string> order = new ChunkedList<string>();
        private readonly ProfilerThread thread;
        private readonly object synchObj = new object();
        private long startTick = 0;
        private long lastTick = 0;
        private string lastName = null;
 
        public Accumulator(ProfilerThread Thread)
        {
            this.thread = Thread;
        }
 
        public void AddAsIs(ProfilerEvent Event)
        {
            long Tick = Event.Ticks;
 
            lock (this.synchObj)
            {
                this.CheckNameLocked(Tick);
                this.lastTick = Tick;
                this.AddLocked(Tick, Event);
            }
        }
 
        private void AddLocked(long Tick, ProfilerEvent Event)
        {
            if (!this.timeline.TryGetValue(Tick, out ChunkedList<ProfilerEvent> Events))
            {
                Events = new ChunkedList<ProfilerEvent>();
                this.timeline[Tick] = Events;
            }
 
            Events.Add(Event);
        }
 
        private void CheckNameLocked(long Tick)
        {
            if (!string.IsNullOrEmpty(this.lastName))
            {
                long Diff = Tick - this.lastTick;
 
                if (this.sumTicks.TryGetValue(this.lastName, out long l))
                    this.sumTicks[this.lastName] = l + Diff;
                else
                {
                    this.sumTicks[this.lastName] = Diff;
                    this.order.Add(this.lastName);
                }
 
                this.lastName = null;
            }
        }
 
        public void Start(Start Event)
        {
            this.startTick = Event.Ticks;
            this.AddAsIs(Event);
        }
 
        public void Idle(Idle Event)
        {
            long Tick = Event.Ticks;
 
            lock (this.synchObj)
            {
                this.CheckNameLocked(Tick);
                this.lastTick = Tick;
            }
        }
 
        public void Sum(NewState Event)
        {
            long Tick = Event.Ticks;
 
            lock (this.synchObj)
            {
                this.CheckNameLocked(Tick);
                this.lastTick = Tick;
                this.lastName = Event.State;
            }
        }
 
        public void Report(ChunkedList<ProfilerEvent> Result)
        {
            lock (this.synchObj)
            {
                long Tick = this.startTick;
 
                foreach (string Name in this.order)
                {
                    if (this.sumTicks.TryGetValue(Name, out long Ticks))
                    {
                        this.AddLocked(Tick, new NewState(Tick, Name, this.thread));
                        Tick += Ticks;
                    }
                }
 
                this.AddLocked(Tick, new Idle(Tick, this.thread));
 
                foreach (ChunkedList<ProfilerEvent> Events in this.timeline.Values)
                    Result.AddRange(Events);
            }
        }
 
    }
}