Code/Tools/Statoscope/Statoscope/EventReader.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.Runtime.InteropServices;
   8 using System.Reflection;
   9
  10 namespace Statoscope
  11 {
  12         enum EventId
  13         {
  14                 EI_DefineClass = 0,
  15                 EI_BeginInterval,
  16                 EI_EndInterval,
  17                 EI_ModifyInterval,
  18                 EI_ModifyIntervalBit,
  19         }
  20
  21         class EventPropertyDesc
  22         {
  23                 public EFrameElementType type;
  24                 public FieldInfo field;
  25
  26                 public EventPropertyDesc(EFrameElementType type, FieldInfo field)
  27                 {
  28                         this.type = type;
  29                         this.field = field;
  30                 }
  31         }
  32
  33         class EventClassDesc
  34         {
  35                 public readonly Type propertiesType;
  36                 public readonly EventPropertyDesc[] properties;
  37
  38                 public EventClassDesc(Type propertiesType, EventPropertyDesc[] properties)
  39                 {
  40                         this.propertiesType = propertiesType;
  41                         this.properties = properties;
  42                 }
  43         }
  44
  45         class EventReader
  46         {
  47                 Dictionary<UInt64, PendingInterval> m_pendingIntervals = new Dictionary<UInt64, PendingInterval>();
  48                 byte m_nextEventSequence = 0;
  49                 Int64 m_lastTimestamp = 0;
  50
  51                 Dictionary<UInt32, EventClassDesc> m_classDescs = new Dictionary<UInt32, EventClassDesc>();
  52                 Dictionary<UInt32, IIntervalSink> m_sinks = new Dictionary<uint, IIntervalSink>();
  53
  54                 public EventReader(IIntervalSink[] intervalSinks)
  55                 {
  56                         foreach (IIntervalSink sink in intervalSinks)
  57                                 m_sinks[sink.ClassId] = sink;
  58                 }
  59
  60                 public void ReadEvents(IBinaryLogDataStream stream)
  61                 {
  62                         UInt32 eventStreamLen = stream.ReadUInt32();
  63                         int eventStreamPos = 0;
  64                         for (eventStreamPos = 0; eventStreamPos < (int)eventStreamLen; )
  65                         {
  66                                 byte eventId = stream.ReadByte();
  67                                 byte sequence = stream.ReadByte();
  68                                 UInt16 eventLengthInWords = stream.ReadUInt16();
  69                                 Int64 timeStamp = stream.ReadInt64();
  70
  71                                 if (sequence != m_nextEventSequence)
  72                                         throw new ApplicationException("Event sequence mismatch");
  73                                 if (timeStamp < m_lastTimestamp)
  74                                         throw new ApplicationException("Timestamps go backwards");
  75
  76                                 ++m_nextEventSequence;
  77                                 m_lastTimestamp = timeStamp;
  78
  79                                 int eventLength = eventLengthInWords * 4 - 12;
  80
  81                                 switch ((EventId)eventId)
  82                                 {
  83                                         case EventId.EI_DefineClass: ReadDefineClass(timeStamp, eventLength, stream); break;
  84                                         case EventId.EI_BeginInterval: ReadBeginInterval(timeStamp, eventLength, stream); break;
  85                                         case EventId.EI_EndInterval: ReadEndInterval(timeStamp, eventLength, stream); break;
  86                                         case EventId.EI_ModifyInterval: ReadModifyInterval(timeStamp, eventLength, stream); break;
  87                                         case EventId.EI_ModifyIntervalBit: ReadModifyIntervalBit(timeStamp, eventLength, stream); break;
  88                                         default: throw new ApplicationException("Unknown event type");
  89                                 }
  90
  91                                 eventStreamPos += eventLengthInWords * 4;
  92                         }
  93
  94                         if (eventStreamPos != eventStreamLen)
  95                                 throw new ApplicationException("Event stream is corrupt");
  96                 }
  97
  98                 private void ReadDefineClass(Int64 timeStamp, int eventLength, IBinaryLogDataStream stream)
  99                 {
 100                         UInt32 classId = stream.ReadUInt32();
 101                         UInt32 numElements = stream.ReadUInt32();
 102
 103                         byte[] descBytes = stream.ReadBytes(eventLength - 8);
 104
 105                         IIntervalSink sink = m_sinks[classId];
 106                         Type propType = sink.PropertiesType;
 107
 108                         EventPropertyDesc[] properties = new EventPropertyDesc[numElements];
 109
 110                         int p = 0;
 111                         for (UInt32 elementIdx = 0; elementIdx < numElements; ++elementIdx)
 112                         {
 113                                 byte typeId = descBytes[p++];
 114
 115                                 int nullTermIdx = Array.IndexOf<byte>(descBytes, 0, p);
 116                                 string name = System.Text.Encoding.ASCII.GetString(descBytes, p, (nullTermIdx >= 0 ? nullTermIdx : descBytes.Length) - p);
 117                                 p = nullTermIdx + 1;
 118
 119                                 // Find a field with the same name in the C# type
 120                                 FieldInfo field = propType.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
 121                                 properties[elementIdx] = new EventPropertyDesc((EFrameElementType)typeId, field);
 122                         }
 123
 124                         m_classDescs[classId] = new EventClassDesc(propType, properties);
 125                 }
 126
 127                 private void ReadBeginInterval(Int64 timeStamp, int eventLength, IBinaryLogDataStream stream)
 128                 {
 129                         UInt64 ivId = stream.ReadUInt64();
 130                         UInt32 classId = stream.ReadUInt32();
 131
 132                         EventClassDesc classDesc = m_classDescs[classId];
 133
 134                         var pi = new PendingInterval();
 135
 136                         Interval iv = (Interval)Activator.CreateInstance(classDesc.propertiesType);
 137                         iv.StartUs = timeStamp;
 138                         iv.EndUs = Int64.MaxValue;
 139
 140                         pi.classId = classId;
 141                         pi.sink = m_sinks[classId];
 142
 143                         byte[] values = stream.ReadBytes(eventLength - 12);
 144
 145                         int p = 0;
 146                         for (int i = 0, c = classDesc.properties.Length; i < c; ++i)
 147                         {
 148                                 object val;
 149
 150                                 switch (classDesc.properties[i].type)
 151                                 {
 152                                         case EFrameElementType.Float:
 153                                                 val = EndianBitConverter.ToSingle(values, p, stream.Endianness);
 154                                                 p += 4;
 155                                                 break;
 156
 157                                         case EFrameElementType.Int:
 158                                                 val = EndianBitConverter.ToInt32(values, p, stream.Endianness);
 159                                                 p += 4;
 160                                                 break;
 161
 162                                         case EFrameElementType.String:
 163                                                 {
 164                                                         int nullTerm = Array.IndexOf<byte>(values, 0, p);
 165                                                         string s = System.Text.Encoding.ASCII.GetString(values, p, nullTerm - p);
 166                                                         p = (nullTerm + 4) & ~3;
 167                                                         val = s;
 168                                                 }
 169                                                 break;
 170
 171                                         case EFrameElementType.Int64:
 172                                                 val = EndianBitConverter.ToInt64(values, p, stream.Endianness);
 173                                                 p += 8;
 174                                                 break;
 175
 176                                         default:
 177                                                 throw new ApplicationException("Unhandled property type");
 178                                 }
 179
 180                                 if (classDesc.properties[i].field != null)
 181                                         classDesc.properties[i].field.SetValue(iv, val);
 182                         }
 183
 184                         pi.iv = iv;
 185                         m_pendingIntervals[ivId] = pi;
 186
 187                         pi.sink.OnBegunInterval(ivId, iv);
 188                 }
 189
 190                 private void ReadModifyInterval(Int64 timeStamp, int eventLength, IBinaryLogDataStream stream)
 191                 {
 192                         UInt64 ivId = stream.ReadUInt64();
 193                         UInt32 classId = stream.ReadUInt32();
 194                         UInt32 field = stream.ReadUInt32();
 195                         UInt32 fieldId = field & 0x7fffffff;
 196                         UInt32 splitInterval = field & 0x80000000;
 197
 198                         byte[] values = stream.ReadBytes(eventLength - 16);
 199
 200                         if (m_pendingIntervals.ContainsKey(ivId))
 201                         {
 202                                 EventClassDesc classDesc = m_classDescs[classId];
 203                                 PendingInterval pi = m_pendingIntervals[ivId];
 204                                 Interval iv = pi.iv;
 205
 206                                 if (splitInterval != 0)
 207                                 {
 208                                         iv.EndUs = timeStamp;
 209
 210                                         Interval ivClone = (Interval)iv.Clone();
 211
 212                                         pi.sink.OnFinalisedInterval(ivId, iv, true);
 213
 214                                         iv = ivClone;
 215                                         pi.iv = iv;
 216                                         iv.StartUs = timeStamp;
 217                                         iv.EndUs = Int64.MaxValue;
 218                                 }
 219
 220                                 EEndian srcEndian = stream.Endianness;
 221
 222                                 object val = null;
 223                                 switch (classDesc.properties[fieldId].type)
 224                                 {
 225                                         case EFrameElementType.Float:
 226                                                 val = EndianBitConverter.ToSingle(values, 0, srcEndian);
 227                                                 break;
 228
 229                                         case EFrameElementType.Int:
 230                                                 val = EndianBitConverter.ToInt32(values, 0, srcEndian);
 231                                                 break;
 232
 233                                         case EFrameElementType.String:
 234                                                 {
 235                                                         int nullTerm = Array.IndexOf<byte>(values, 0, 0);
 236                                                         string s = System.Text.Encoding.ASCII.GetString(values, 0, nullTerm);
 237                                                         val = s;
 238                                                 }
 239                                                 break;
 240
 241                                         case EFrameElementType.Int64:
 242                                                 val = EndianBitConverter.ToInt64(values, 0, srcEndian);
 243                                                 break;
 244
 245                                         default:
 246                                                 throw new ApplicationException("Unhandled property type");
 247                                 }
 248
 249                                 if (classDesc.properties[fieldId].field != null)
 250                                         classDesc.properties[fieldId].field.SetValue(iv, val);
 251
 252                                 if (splitInterval != 0)
 253                                 {
 254                                         pi.sink.OnBegunInterval(ivId, iv);
 255                                 }
 256                         }
 257                         else
 258                         {
 259                                 //throw new ApplicationException("Unknown interval");
 260                         }
 261                 }
 262
 263                 private void ReadModifyIntervalBit(Int64 timeStamp, int eventLength, IBinaryLogDataStream stream)
 264                 {
 265                         UInt64 ivId = stream.ReadUInt64();
 266                         UInt32 classId = stream.ReadUInt32();
 267                         UInt32 field = stream.ReadUInt32();
 268                         UInt32 fieldId = field & 0x7fffffff;
 269                         UInt32 splitInterval = field & 0x80000000;
 270
 271                         byte[] values = stream.ReadBytes(eventLength - 16);
 272
 273                         if (m_pendingIntervals.ContainsKey(ivId))
 274                         {
 275                                 EventClassDesc classDesc = m_classDescs[classId];
 276                                 PendingInterval pi = m_pendingIntervals[ivId];
 277                                 Interval iv = pi.iv;
 278
 279                                 if (splitInterval != 0)
 280                                 {
 281                                         iv.EndUs = timeStamp;
 282
 283                                         Interval ivClone = (Interval)iv.Clone();
 284
 285                                         pi.sink.OnFinalisedInterval(ivId, iv, true);
 286
 287                                         iv = ivClone;
 288                                         pi.iv = iv;
 289                                         iv.StartUs = timeStamp;
 290                                         iv.EndUs = Int64.MaxValue;
 291                                 }
 292
 293                                 EEndian srcEndian = stream.Endianness;
 294
 295                                 object valMask = null, valOr = null;
 296                                 switch (classDesc.properties[fieldId].type)
 297                                 {
 298                                         case EFrameElementType.Int:
 299                                                 valMask = EndianBitConverter.ToInt32(values, 0, srcEndian);
 300                                                 valOr = EndianBitConverter.ToInt32(values, 4, srcEndian);
 301                                                 break;
 302
 303                                         case EFrameElementType.Int64:
 304                                                 valMask = EndianBitConverter.ToInt64(values, 0, srcEndian);
 305                                                 valOr = EndianBitConverter.ToInt64(values, 8, srcEndian);
 306                                                 break;
 307
 308                                         default:
 309                                                 throw new ApplicationException("Unhandled property type");
 310                                 }
 311
 312                                 if (classDesc.properties[fieldId].field != null)
 313                                 {
 314                                         object oldVal = classDesc.properties[fieldId].field.GetValue(iv);
 315
 316                                         switch (classDesc.properties[fieldId].type)
 317                                         {
 318                                                 case EFrameElementType.Int:
 319                                                         classDesc.properties[fieldId].field.SetValue(iv, ((int)oldVal & (int)valMask) | ((int)valOr));
 320                                                         break;
 321
 322                                                 case EFrameElementType.Int64:
 323                                                         classDesc.properties[fieldId].field.SetValue(iv, ((long)oldVal & (long)valMask) | ((long)valOr));
 324                                                         break;
 325                                         }
 326                                 }
 327
 328                                 if (splitInterval != 0)
 329                                 {
 330                                         pi.sink.OnBegunInterval(ivId, iv);
 331                                 }
 332                         }
 333                         else
 334                         {
 335                                 //throw new ApplicationException("Unknown interval");
 336                         }
 337                 }
 338
 339                 private void ReadEndInterval(Int64 timeStamp, int eventLength, IBinaryLogDataStream stream)
 340                 {
 341                         UInt64 ivId = stream.ReadUInt64();
 342
 343                         if (m_pendingIntervals.ContainsKey(ivId))
 344                         {
 345                                 PendingInterval pi = m_pendingIntervals[ivId];
 346                                 Interval iv = pi.iv;
 347
 348                                 iv.EndUs = timeStamp;
 349                                 pi.sink.OnFinalisedInterval(ivId, iv, false);
 350
 351                                 m_pendingIntervals.Remove(ivId);
 352                         }
 353                 }
 354
 355                 class PendingInterval
 356                 {
 357                         public UInt32 classId;
 358
 359                         public Interval iv;
 360                         public IIntervalSink sink;
 361                 }
 362         }
 363 }