Code/Tools/Statoscope/Statoscope/StreamingBucket.cs

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 using System;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Text;
   7 using System.ComponentModel;
   8
   9 namespace Statoscope
  10 {
  11   class BucketTimeRange
  12   {
  13     private TimeSpan m_min;
  14     private TimeSpan m_max;
  15
  16     public TimeSpan Min
  17     {
  18       get { return m_min; }
  19     }
  20
  21     public TimeSpan Max
  22     {
  23       get { return m_max; }
  24     }
  25
  26     public BucketTimeRange(TimeSpan min, TimeSpan max)
  27     {
  28       m_min = min;
  29       m_max = max;
  30     }
  31   }
  32
  33   class StreamingTimeBucket : Bucket
  34   {
  35     [Description("Count")]
  36     public int Num
  37     {
  38       get { return m_num; }
  39       set { m_num = value; }
  40     }
  41
  42     [Description("%")]
  43     public float NumPc
  44     {
  45       get { return m_numPc; }
  46       set { m_numPc = value; }
  47     }
  48
  49     [Description("% Cumulative")]
  50     public float NumPcCumulative
  51     {
  52       get { return m_numPcCumulative; }
  53       set { m_numPcCumulative = value; }
  54     }
  55
  56     public StreamingTimeBucket(string rangeStr)
  57       : base(rangeStr)
  58     {
  59     }
  60
  61     private int m_num;
  62     private float m_numPc;
  63     private float m_numPcCumulative;
  64   }
  65
  66   class StreamingTypeBucket : Bucket
  67   {
  68     [Description("Count")]
  69     public int Num
  70     {
  71       get { return m_num; }
  72       set { m_num = value; }
  73     }
  74
  75     [Description("%")]
  76     public float NumPc
  77     {
  78       get { return m_numPc; }
  79       set { m_numPc = value; }
  80     }
  81
  82     public StreamingTypeBucket(string rangeStr)
  83       : base(rangeStr)
  84     {
  85     }
  86
  87     private int m_num;
  88     private float m_numPc;
  89   }
  90
  91   class StreamingTypeBucketSet : BucketSet
  92   {
  93     private readonly StreamTaskType[] m_types;
  94     private readonly Dictionary<StreamTaskType, int> m_typeToBucket = new Dictionary<StreamTaskType, int>();
  95     private int m_total;
  96
  97     public override bool IsEmpty
  98     {
  99       get { return m_total == 0; }
 100     }
 101
 102     public StreamingTypeBucketSet(StreamTaskType[] types)
 103       : base(CreateBuckets(types))
 104     {
 105       m_types = types;
 106
 107       for (int i = 0, c = types.Length; i != c; ++i)
 108         m_typeToBucket[types[i]] = i;
 109     }
 110
 111     public void AddInterval(StreamingInterval iv)
 112     {
 113       ++m_total;
 114
 115       int bucketIdx = m_typeToBucket[iv.Source];
 116       StreamingTypeBucket bucket = m_buckets[bucketIdx] as StreamingTypeBucket;
 117       ++bucket.Num;
 118
 119       UpdatePc();
 120     }
 121
 122     private void UpdatePc()
 123     {
 124       float total = m_total;
 125       for (int i = 0; i < m_buckets.Count; ++i)
 126       {
 127         StreamingTypeBucket bucket = m_buckets[i] as StreamingTypeBucket;
 128         bucket.NumPc = Math.Min(100.0f, 100.0f * bucket.Num / total);
 129       }
 130     }
 131
 132     private static List<Bucket> CreateBuckets(StreamTaskType[] types)
 133     {
 134       List<Bucket> l = new List<Bucket>(types.Length);
 135
 136       foreach (StreamTaskType i in types)
 137         l.Add(new StreamingTypeBucket(i.ToString()));
 138
 139       return l;
 140     }
 141   }
 142
 143   class StreamingTimeBucketSet : BucketSet
 144   {
 145     private readonly BucketTimeRange[] m_ranges;
 146                 private int m_total;
 147
 148     public override bool IsEmpty
 149     {
 150       get { return m_total == 0; }
 151     }
 152
 153     public StreamingTimeBucketSet(BucketTimeRange[] ranges)
 154       : base(CreateBuckets(ranges))
 155     {
 156       m_ranges = ranges;
 157       m_total = 0;
 158     }
 159
 160     public void AddIntervals(IEnumerable<StreamingInterval> ivs)
 161     {
 162       foreach (StreamingInterval iv in ivs)
 163         AddInterval(iv.Length);
 164     }
 165
 166     public void AddInterval(double length)
 167     {
 168       ++m_total;
 169
 170       TimeSpan ivts = new TimeSpan((long)(length * 1000.0 * 1000.0 * 10.0));
 171       int bucketIdx = m_ranges.MappedBinarySearchIndex(ivts, (x) => x.Min, (a, b) => a < b);
 172       StreamingTimeBucket bucket = (StreamingTimeBucket)m_buckets[bucketIdx];
 173
 174       ++bucket.Num;
 175       bucket.NumPc = Math.Min(100.0f, 100.0f * (bucket.Num / (float)m_total));
 176
 177       UpdatePc();
 178     }
 179
 180     private void UpdatePc()
 181     {
 182       float total = (float)m_total;
 183       int numCumulative = 0;
 184
 185       for (int i = 0, c = m_buckets.Count; i < c; ++i)
 186       {
 187         StreamingTimeBucket sb = m_buckets[i] as StreamingTimeBucket;
 188         numCumulative += sb.Num;
 189         sb.NumPc = Math.Min(100.0f, 100.0f * sb.Num / total);
 190         sb.NumPcCumulative = Math.Min(100.0f, 100.0f * (numCumulative / total));
 191       }
 192     }
 193
 194     static private List<Bucket> CreateBuckets(BucketTimeRange[] ranges)
 195     {
 196       List<Bucket> buckets = new List<Bucket>();
 197       foreach (BucketTimeRange r in ranges)
 198       {
 199         string s = "";
 200         if (r.Min > new TimeSpan(0))
 201           s += string.Format("{0}ms", r.Min.TotalMilliseconds);
 202         s += "-";
 203         if (r.Max < TimeSpan.MaxValue)
 204           s += string.Format("{0}ms", r.Max.TotalMilliseconds);
 205         buckets.Add(new StreamingTimeBucket(s));
 206       }
 207       return buckets;
 208     }
 209   }
 210 }