Code/Tools/Statoscope/Statoscope/FrameRecord.cs

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 using System;
   4 using System.Collections.Generic;
   5 using System.IO;
   6 using System.Linq;
   7 using System.Text.RegularExpressions;
   8 using System.Threading;
   9
  10 namespace Statoscope
  11 {
  12         enum EFrameElementValueType
  13         {
  14                 Float,
  15                 Int
  16         }
  17
  18         enum EFrameElementType
  19         {
  20                 None = 0,
  21                 Float,
  22                 Int,
  23                 String,
  24                 B64Texture,
  25                 Int64,
  26         }
  27
  28         enum EEndian
  29         {
  30                 LITTLE_ENDIAN = 0,
  31                 BIG_ENDIAN
  32         }
  33
  34         class PerfStatFrameElement
  35         {
  36                 public EFrameElementType m_type;
  37                 public string m_name;
  38                 public string m_units;
  39
  40                 public PerfStatFrameElement(string type, string name, string units)
  41                 {
  42                         switch (type)
  43                         {
  44                         case "float":
  45                                 m_type = EFrameElementType.Float;
  46                                 break;
  47
  48                         case "int":
  49                                 m_type = EFrameElementType.Int;
  50                                 break;
  51
  52                         case "string":
  53                                 m_type = EFrameElementType.String;
  54                                 break;
  55
  56                         case "b64texture":
  57                                 m_type = EFrameElementType.B64Texture;
  58                                 break;
  59                         }
  60
  61                         m_name = name;
  62                         m_units = units;
  63                 }
  64
  65                 public PerfStatFrameElement(EFrameElementType _type, string name, string units)
  66                 {
  67                         m_type = _type;
  68                         m_name = name;
  69                         m_units = units;
  70                 }
  71
  72                 public static string GetRegexPatternFromFrameElementType(EFrameElementType type)
  73                 {
  74                         switch (type)
  75                         {
  76                         case EFrameElementType.Float:
  77                         case EFrameElementType.Int:
  78                                 return @"-?\d+(\.\d+)?|1\.\#QNAN0";
  79
  80                         case EFrameElementType.String:
  81                                 return @"'.*?'";
  82
  83                         case EFrameElementType.B64Texture:
  84                                 return @"[A-Z|a-z|0-9|\+|\/]*";
  85                         }
  86
  87                         return "";
  88                 }
  89
  90                 public string GetRegexPattern()
  91                 {
  92                         return string.Format("(?<{0}>{1}) *", m_name, GetRegexPatternFromFrameElementType(m_type));
  93                 }
  94         }
  95
  96         struct ProfileTotalData
  97         {
  98                 public FrameRecord m_fr;
  99                 public List<string> m_paths;
 100                 public MTCounter m_profileTotalCounter;
 101
 102                 public ProfileTotalData(FrameRecord fr, List<string> paths, MTCounter profileTotalCounter)
 103                 {
 104                         m_fr = fr;
 105                         m_paths = paths;
 106                         m_profileTotalCounter = profileTotalCounter;
 107                 }
 108         }
 109
 110         public class Callstack
 111         {
 112                 public string m_tag;
 113                 public List<string> m_functions;
 114
 115                 public Callstack(string tag)
 116                 {
 117                         m_tag = tag;
 118                         m_functions = new List<string>();
 119                 }
 120         }
 121
 122         public class FrameRecord
 123         {
 124                 public readonly int                     Index;                                          // the index into the frame records of the LogData that this belongs to
 125                 public readonly float           FrameTimeInS;                   // when the frame started in seconds
 126                 public                                  float           FrameMidTimeInS;        // half way between the start of this frame and the start of the next frame (or FrameTimeInS for the last frame)
 127                 public readonly MemoryStream    ScreenshotImage;
 128
 129                 public readonly IReadOnlyFRVs                                                                           Values;
 130                 public readonly IEnumerable<UserMarkerLocation> UserMarkers;
 131                 public readonly IEnumerable<Callstack>                                  Callstacks;
 132
 133                 public FrameRecord(int index, float frameTimeInS, MemoryStream screenshotImage, IReadOnlyFRVs values, IEnumerable<UserMarker> userMarkers, IEnumerable<Callstack> callstacks)
 134                 {
 135                         Index = index;
 136                         FrameTimeInS = frameTimeInS;
 137                         FrameMidTimeInS = frameTimeInS;
 138                         ScreenshotImage = screenshotImage;
 139                         Values = values;
 140
 141                         List<UserMarkerLocation> userMarkerLocs = new List<UserMarkerLocation>();
 142
 143                         foreach (UserMarker userMarker in userMarkers)
 144                         {
 145                                 UserMarkerLocation userMarkerLocation = new UserMarkerLocation(userMarker, this, userMarkerLocs.Count);
 146                                 userMarkerLocs.Add(userMarkerLocation);
 147                         }
 148
 149                         UserMarkers = userMarkerLocs;
 150
 151                         Callstacks = callstacks;
 152                 }
 153
 154                 public void CalculateFrameMidTime(FrameRecord nextFR)
 155                 {
 156                         FrameMidTimeInS = (this.FrameTimeInS + nextFR.FrameTimeInS) / 2.0f;
 157                 }
 158
 159                 // checks if path matches pattern, delimitted by /, where a * in pattern matches any single item in path
 160                 // and a ** in pattern matches any number of / seperated items
 161                 // e.g. PathMatchesPattern("/a/b/c", "/a/b/c") == true
 162                 //                      PathMatchesPattern("/a/b/c", "/a/*/c") == true
 163                 //                      PathMatchesPattern("/a/b/c", "/*/c") == false
 164                 //                      PathMatchesPattern("/a/b/c", "/**/c") == true
 165                 public static bool PathMatchesPattern(string path, string pattern)
 166                 {
 167                         string[] pathLocations = path.PathLocations();
 168                         string[] patternLocations = pattern.PathLocations();
 169                         bool containsDoubleStar = false;
 170                         int iPattern = 0;
 171
 172                         for (int iPath = 0; iPath < pathLocations.Length && iPattern < patternLocations.Length; iPath++)
 173                         {
 174                                 if (patternLocations[iPattern] == "*")
 175                                 {
 176                                         iPattern++;
 177                                         continue;
 178                                 }
 179
 180                                 if (patternLocations[iPattern] == "**")
 181                                 {
 182                                         if (iPattern == patternLocations.Length - 1)
 183                                         {
 184                                                 return true;
 185                                         }
 186
 187                                         containsDoubleStar = true;
 188
 189                                         if (patternLocations[iPattern + 1] == pathLocations[iPath])
 190                                         {
 191                                                 iPattern++;
 192                                         }
 193
 194                                         continue;
 195                                 }
 196
 197                                 if (patternLocations[iPattern] != pathLocations[iPath])
 198                                 {
 199                                         return false;
 200                                 }
 201
 202                                 iPattern++;
 203                         }
 204
 205                         return (containsDoubleStar && iPattern == patternLocations.Length) || (pathLocations.Length == patternLocations.Length);
 206                 }
 207
 208                 // value paths
 209                 public IEnumerable<string> GetPathEnumerator(string pathToDo)
 210                 {
 211                         foreach (string path in Values.Paths)
 212                         {
 213                                 if (PathMatchesPattern(path, pathToDo))
 214                                 {
 215                                         yield return path;
 216                                 }
 217                         }
 218                 }
 219
 220                 public float GetDisplayXValue(LogData logData, bool againstFrameTime)
 221                 {
 222                         if (againstFrameTime)
 223                         {
 224                                 float startMidTime = logData.FrameRecords.First().FrameMidTimeInS;
 225                                 return FrameMidTimeInS - startMidTime;
 226                         }
 227                         else
 228                         {
 229                                 return logData.GetDisplayIndex(Index) + 0.5f;
 230                         }
 231                 }
 232         }
 233
 234         public delegate float GetRecordValue(FrameRecord record);
 235         delegate bool AcceptRecord(FrameRecord record);
 236         public delegate IReadOnlyFRVs GetValuesFromIndex(int i);
 237
 238         class PerfStatLogLineDescriptor
 239         {
 240                 public List<PerfStatFrameElement> m_formatElements = new List<PerfStatFrameElement>();
 241                 public string m_path;
 242                 public Regex m_regex;
 243
 244                 public void CreateRegex()
 245                 {
 246                         string formatRegexPattern = @"\[";
 247
 248                         foreach (PerfStatFrameElement fe in m_formatElements)
 249                         {
 250                                 formatRegexPattern += fe.GetRegexPattern();
 251                         }
 252
 253                         formatRegexPattern += @"\]";
 254
 255                         m_regex = new Regex(formatRegexPattern);
 256                 }
 257         }
 258
 259         class SocketLogData : LogData
 260         {
 261                 List<LogView> LogViews = new List<LogView>();
 262                 SocketLogBinaryDataStream SocketDataStream;
 263                 public bool m_bTempFile = false;
 264                 public string m_logWriteFilename = "";
 265
 266                 public SocketLogBinaryDataStream DataStream { set { SocketDataStream = value; } }
 267
 268                 public SocketLogData(SocketSessionInfo session)
 269                 : base(session)
 270                 {
 271                 }
 272
 273                 public void SaveToFile(string fileName)
 274                 {
 275                         File.Copy(m_logWriteFilename, fileName, true);
 276                 }
 277
 278                 public override void AddFrameRecord(FrameRecord fr, List<KeyValuePair<string, EItemType>> newMetaDatas)
 279                 {
 280                         lock (this)
 281                         {
 282                                 base.AddFrameRecord(fr, newMetaDatas);
 283                                 ProcessRecords(fr.Index);
 284                         }
 285
 286                         foreach (LogView logView in LogViews)
 287                         {
 288                                 logView.m_logControl.NewRecordsAvailable();
 289                         }
 290
 291                         //m_logControl.UpdateControls(fr.m_index);      // change this to a listener setup? and also only do it for the views that have this log data
 292                 }
 293
 294                 public void AddListeningLogView(LogView logView)
 295                 {
 296                         LogViews.Add(logView);
 297                 }
 298
 299                 public void RemoveListeningLogView(LogView logView)
 300                 {
 301                         LogViews.Remove(logView);
 302
 303                         if (LogViews.Count == 0)
 304                         {
 305                                 // trigger the socket thread shutdown
 306                                 SocketDataStream.CloseNetStream();
 307
 308                                 if (m_bTempFile && m_logWriteFilename != "")
 309                                 {
 310                                         File.Delete(m_logWriteFilename);
 311                                         m_logWriteFilename = "";
 312                                 }
 313
 314                                 for (int i = 0; (i < 10) && SocketDataStream.FileWriterNeedsClosing; i++)
 315                                 {
 316                                         Thread.Sleep(100);
 317                                 }
 318                         }
 319                 }
 320         }
 321
 322         public class FrameRecordRange
 323         {
 324                 public readonly string Name;    // this is only really used for the Confluence stuff now and ideally should be removed
 325                 public readonly int StartIdx;
 326                 public readonly int EndIdx;
 327
 328                 public FrameRecordRange()
 329                 {
 330                         Name = "";
 331                         StartIdx = 0;
 332                         EndIdx = 0;
 333                 }
 334
 335                 public FrameRecordRange(string name, int startIdx, int endIdx)
 336                 {
 337                         Name = name;
 338                         StartIdx = startIdx;
 339                         EndIdx = endIdx;
 340                 }
 341         }
 342
 343         public class LogRange
 344         {
 345                 public LogData m_logData;
 346                 public FrameRecordRange m_frr;
 347
 348                 public LogRange(LogData logData, FrameRecordRange frr)
 349                 {
 350                         m_logData = logData;
 351                         m_frr = frr;
 352                 }
 353         }
 354
 355         public class UserMarkerLocation
 356         {
 357                 public string m_path;
 358                 public string m_name;
 359                 public FrameRecord m_fr;
 360                 public int m_index;     // the index of this UserMarkerLocation in m_fr.UserMarkers
 361
 362                 public UserMarkerLocation(UserMarker userMarker, FrameRecord fr, int index)
 363                 {
 364                         m_path = userMarker.Path;
 365                         m_name = userMarker.Name;
 366                         m_fr = fr;
 367                         m_index = index;
 368                 }
 369
 370                 public string GetNameForLogView(LogView logView)
 371                 {
 372                         return logView.Index + "." + m_fr.Index + "." + m_index + " " + m_name;
 373                 }
 374
 375                 static string oldLevelStartString = "level_start ";
 376                 static string newLevelStartString = "Start ";
 377
 378                 bool IsOldLevelStart()  { return m_name.StartsWith(oldLevelStartString); }
 379                 bool IsNewLevelStart()  { return m_path == "/UserMarkers/Level" && m_name.StartsWith(newLevelStartString); }
 380                 public bool IsLevelStart()                      { return IsOldLevelStart() || IsNewLevelStart(); }
 381                 public bool IsLevelEnd()                                {       return (m_name == "level_end") || ((m_path == "/UserMarkers/Level") && (m_name == "Start")); }
 382
 383                 public string GetLevelName()
 384                 {
 385                         if (IsOldLevelStart())
 386                         {
 387                                 return m_name.Substring(oldLevelStartString.Length);
 388                         }
 389                         else if (IsNewLevelStart())
 390                         {
 391                                 return m_name.Substring(newLevelStartString.Length);
 392                         }
 393                         else
 394                         {
 395                                 throw new Exception("Not a level user marker");
 396                         }
 397                 }
 398         }
 399
 400         public class Stats
 401         {
 402                 public float m_min;
 403                 public float m_max;
 404                 public float m_avg;
 405
 406                 public Stats()
 407                 {
 408                         m_min = 9999999999999.0f;
 409                         m_max = 0.0f;
 410                         m_avg = 0.0f;
 411                 }
 412         }
 413
 414         public class GroupItemStats
 415         {
 416                 public GroupItemStats()
 417                 {
 418                         m_groupItemStats = new Dictionary<string, Stats>();
 419                 }
 420                 public Stats GetItemStats(string item)
 421                 {
 422                         return m_groupItemStats[item];
 423                 }
 424                 public bool ContainsItem(string item)
 425                 {
 426                         return m_groupItemStats.ContainsKey(item);
 427                 }
 428                 public Dictionary<string, Stats> m_groupItemStats;
 429         }
 430
 431         public class GroupsStats
 432         {
 433                 public GroupsStats()
 434                 {
 435                         m_groupStats = new Dictionary<string, GroupItemStats>();
 436                 }
 437                 public GroupItemStats GetGroupItemsStats(string group)
 438                 {
 439                         return m_groupStats[group];
 440                 }
 441                 public bool ContainsGroup(string group)
 442                 {
 443                         return m_groupStats.ContainsKey(group);
 444                 }
 445                 public Dictionary<string, GroupItemStats> m_groupStats;
 446         }
 447
 448         public class ValueStats
 449         {
 450                 public readonly bool m_bValueIsPerLogView;
 451                 public int m_numFrames;
 452                 public float m_min;
 453                 public float m_max;
 454                 public float m_avg;
 455                 double m_total;
 456
 457                 public ValueStats(bool bValueIsPerLogView)
 458                 {
 459                         m_bValueIsPerLogView = bValueIsPerLogView;
 460                         Reset();
 461                 }
 462
 463                 public void Reset()
 464                 {
 465                         m_numFrames = 0;
 466                         m_min = float.MaxValue;
 467                         m_max = float.MinValue;
 468                         m_avg = 0.0f;
 469                         m_total = 0.0;
 470                 }
 471
 472                 public void Update(float value)
 473                 {
 474                         if (float.IsNaN(value))
 475                         {
 476                                 return;
 477                         }
 478
 479                         m_numFrames++;
 480
 481                         if (value < m_min)
 482                         {
 483                                 m_min = value;
 484                         }
 485
 486                         if (value > m_max)
 487                         {
 488                                 m_max = value;
 489                         }
 490
 491                         m_total += value;
 492                         m_avg = (float)(m_total / m_numFrames);
 493                 }
 494         }
 495
 496         public enum EItemType
 497         {
 498                 NotSet,
 499                 Float,
 500                 Int
 501         }
 502
 503         public class ItemMetaData
 504         {
 505                 public EItemType m_type;
 506
 507                 public ItemMetaData(EItemType type)
 508                 {
 509                         m_type = type;
 510                 }
 511
 512                 public override bool Equals(object obj)
 513                 {
 514                         if (obj == null || GetType() != obj.GetType())
 515                         {
 516                                 return false;
 517                         }
 518
 519                         ItemMetaData imd = (ItemMetaData)(obj);
 520                         return imd.m_type == m_type;
 521                 }
 522
 523                 public override int GetHashCode()
 524                 {
 525                         return m_type.GetHashCode();
 526                 }
 527         }
 528
 529         public partial class LogData
 530         {
 531                 public readonly string Name;
 532                 public readonly List<FrameRecord> FrameRecords;
 533                 public readonly Dictionary<string, ItemMetaData> ItemMetaData;  // things selectable in the treeview or possibly in bucket stats need meta data
 534                 public IEnumerable<FrameRecordRange> LevelRanges { get { return m_levelRanges; } }
 535                 public readonly FrameRecordRange FrameRecordRange;
 536                 public readonly BuildInfo BuildInfo;    // only used for Confluence, which I'd like to remove; however, FFM may still use it
 537                 public readonly SessionInfo SessionInfo;
 538                 public IReadOnlyFRPC Paths { get { return m_paths; } }
 539
 540                 public readonly IntervalTree IntervalTree = new IntervalTree();
 541
 542                 readonly List<FrameRecordRange> m_levelRanges = new List<FrameRecordRange>();
 543                 readonly FrameRecordPathCollection m_paths;
 544
 545                 public LogData(SessionInfo sessionInfo)
 546                 {
 547                         Name = sessionInfo.Summary;
 548                         FrameRecords = new List<FrameRecord>();
 549                         ItemMetaData = new Dictionary<string, ItemMetaData>();
 550                         FrameRecordRange = new FrameRecordRange();
 551                         BuildInfo = new BuildInfo(Name);
 552                         SessionInfo = sessionInfo;
 553                         m_paths = new FrameRecordPathCollection();
 554                 }
 555
 556                 public LogData(LogData logData, FrameRecordRange frr)
 557                 {
 558                         int startIdx = frr.StartIdx;
 559                         int endIdx = frr.EndIdx;
 560                         int numFrames = endIdx - startIdx + 1;
 561
 562                         Name = frr.Name;
 563                         FrameRecords = new List<FrameRecord>(logData.FrameRecords.GetRange(startIdx, numFrames));
 564                         ItemMetaData = new Dictionary<string, ItemMetaData>(logData.ItemMetaData);      // this may not need to be copied, MT a problem though?
 565                         FrameRecordRange = new FrameRecordRange(Name, logData.FrameRecordRange.StartIdx + startIdx,
 566                                                                 logData.FrameRecordRange.StartIdx + endIdx);
 567                         m_paths = logData.m_paths;
 568                         BuildInfo = logData.BuildInfo;
 569                         SessionInfo = logData.SessionInfo;
 570                 }
 571
 572                 public FrameRecordValues CreateNewFrameRecordValues(FrameRecordValues values)
 573                 {
 574                         // make a new one based on m_paths
 575                         return new FrameRecordValues(m_paths, values);
 576                 }
 577
 578                 public override string ToString()
 579                 {
 580                         return Name;
 581                 }
 582
 583                 public virtual void AddFrameRecord(FrameRecord fr, List<KeyValuePair<string, EItemType>> newMetaDatas)
 584                 {
 585                         for (int i = 0, c = newMetaDatas.Count; i != c; ++ i)
 586                         {
 587                                 SetItemMetaData(newMetaDatas[i].Key, newMetaDatas[i].Value);
 588                         }
 589
 590                         FrameRecords.Add(fr);
 591                 }
 592
 593                 public float LogStartInSeconds
 594                 {
 595                         get
 596                         {
 597                                 if (FrameRecords.Count > 0)
 598                                 {
 599                                         return FrameRecords.First().FrameTimeInS;
 600                                 }
 601
 602                                 return 0.0f;
 603                         }
 604                 }
 605
 606                 public float LogEndInSeconds
 607                 {
 608                         get
 609                         {
 610                                 if (FrameRecords.Count > 0)
 611                                 {
 612                                         return FrameRecords.Last().FrameTimeInS;
 613                                 }
 614
 615                                 return 0.0f;
 616                         }
 617                 }
 618
 619                 public int GetDisplayIndex(int idx)
 620                 {
 621                         return idx - FrameRecordRange.StartIdx;
 622                 }
 623
 624                 public void ProcessRecords()
 625                 {
 626                         ProcessRecords(0);
 627                         CalculateLevelRanges();
 628                 }
 629
 630                 public void ProcessRecords(int fromIdx)
 631                 {
 632                         ClipIncompleteFrames(fromIdx);
 633                         CalculateMidTimes(fromIdx);
 634                         CalculateBucketSets(fromIdx);
 635                         UpdateSessionInfo();
 636                 }
 637
 638                 void UpdateSessionInfo()
 639                 {
 640                         float startTime = (FrameRecords.Count > 0) ? FrameRecords.First().FrameTimeInS : 0.0f;
 641                         float endTime           = (FrameRecords.Count > 0) ? FrameRecords.Last().FrameTimeInS : 0.0f;
 642                         SessionInfo.Update(FrameRecords.Count, startTime, endTime);
 643                 }
 644
 645                 protected void CalculateMidTimes(int fromIdx)
 646                 {
 647                         if (FrameRecords.Count == 0)
 648                         {
 649                                 return;
 650                         }
 651
 652                         for (int i = fromIdx; i < FrameRecords.Count - 1; i++)
 653                         {
 654                                 FrameRecords[i].CalculateFrameMidTime(FrameRecords[i + 1]);
 655                         }
 656                 }
 657
 658                 public float GetMovingAverage(int frame, int numFrames, string path)
 659                 {
 660                         float avgValue = 0.0f;
 661                         int startFrame = Math.Max(0, frame - numFrames);
 662                         int endFrame = Math.Min(frame + numFrames, FrameRecords.Count);
 663                         int numFramesPresent = 0;
 664
 665                         for (int i = startFrame; i < endFrame; i++)
 666                         {
 667                                 IReadOnlyFRVs frv = FrameRecords[i].Values;
 668
 669                                 if (frv.ContainsPath(path))
 670                                 {
 671                                         avgValue += frv[path];
 672                                         numFramesPresent++;
 673                                 }
 674                         }
 675
 676                         return avgValue / numFramesPresent;
 677                 }
 678
 679                 public float GetLocalMax(int frame, int numFrames, string path)
 680                 {
 681                         float maxValue = 0.0f;
 682                         int startFrame = Math.Max(0, frame - numFrames);
 683                         int endFrame = Math.Min(frame, FrameRecords.Count - 1);
 684
 685                         for (int i = startFrame; i <= endFrame; i++)
 686                         {
 687                                 IReadOnlyFRVs frv = FrameRecords[i].Values;
 688
 689                                 if (frv.ContainsPath(path))
 690                                 {
 691                                         maxValue = Math.Max(maxValue, frv[path]);
 692                                 }
 693                         }
 694
 695                         return maxValue;
 696                 }
 697
 698                 protected void ClipIncompleteFrames(int fromIdx)
 699                 {
 700                         for (int i = fromIdx; i < FrameRecords.Count; i++)
 701                         {
 702                                 FrameRecord fr = FrameRecords[i];
 703
 704                                 if (fr.Values.IsEmpty) //ContainsKey("/frameTimeInS"))
 705                                 {
 706                                         FrameRecords.RemoveRange(i, FrameRecords.Count - i);
 707                                         break;
 708                                 }
 709                         }
 710                 }
 711
 712                 public FrameRecord FindClosestScreenshotFrameFromTime(float x)
 713                 {
 714                         return FrameRecords[FindClosestFrameIdxFromTime(x, true)];
 715                 }
 716
 717                 public FrameRecord FindClosestScreenshotFrameFromFrameIdx(int idx)
 718                 {
 719                         int belowIdx;
 720
 721                         for (belowIdx = idx; belowIdx >= 0; belowIdx--)
 722                         {
 723                                 FrameRecord fr = FrameRecords[belowIdx];
 724
 725                                 if (fr.ScreenshotImage != null)
 726                                 {
 727                                         break;
 728                                 }
 729                         }
 730
 731                         int aboveIdx;
 732
 733                         for (aboveIdx = idx; aboveIdx < FrameRecords.Count; aboveIdx++)
 734                         {
 735                                 FrameRecord fr = FrameRecords[aboveIdx];
 736
 737                                 if (fr.ScreenshotImage != null)
 738                                 {
 739                                         break;
 740                                 }
 741                         }
 742
 743                         belowIdx = Math.Max(0, belowIdx);
 744                         aboveIdx = Math.Min(belowIdx, FrameRecords.Count);
 745
 746                         int bestIdx = (idx - belowIdx) < (aboveIdx - idx) ? belowIdx : aboveIdx;
 747                         return FrameRecords[bestIdx];
 748                 }
 749
 750                 public int FindClosestFrameIdxFromTime(float x)
 751                 {
 752                         return FindClosestFrameIdxFromTime(x, false);
 753                 }
 754
 755                 public int FindClosestFrameIdxFromTime(float x, bool screenshotFrame)
 756                 {
 757                         int aboveIdx = 0;
 758                         int belowIdx = 0;
 759                         float startMidTime = FrameRecords.First().FrameMidTimeInS;
 760
 761                         for (int i = 0; i < FrameRecords.Count - 1; i++)
 762                         {
 763                                 FrameRecord fr = FrameRecords[i];
 764
 765                                 if (screenshotFrame && (fr.ScreenshotImage == null))
 766                                 {
 767                                         continue;
 768                                 }
 769
 770                                 if (x < fr.FrameMidTimeInS - startMidTime)
 771                                 {
 772                                         aboveIdx = i;
 773                                         break;
 774                                 }
 775
 776                                 belowIdx = i;
 777                         }
 778
 779                         aboveIdx = Math.Max(aboveIdx, belowIdx);
 780
 781                         if (x > (FrameRecords[aboveIdx].FrameMidTimeInS - startMidTime + FrameRecords[belowIdx].FrameMidTimeInS - startMidTime) / 2.0f)
 782                         {
 783                                 return aboveIdx;
 784                         }
 785                         else
 786                         {
 787                                 return belowIdx;
 788                         }
 789                 }
 790
 791                 public void GetFrameTimeData(int fromFrameIdx, int toFrameIdx, out float min, out float max, out float avg)
 792                 {
 793                         min = float.MaxValue;
 794                         max = 0.0f;
 795                         avg = 0.0f;
 796
 797                         for (int i = fromFrameIdx; i <= toFrameIdx; i++)
 798                         {
 799                                 FrameRecord fr = FrameRecords[i];
 800                                 float frameLengthInMS = fr.Values["/frameLengthInMS"];
 801                                 min = Math.Min(min, frameLengthInMS);
 802                                 max = Math.Max(max, frameLengthInMS);
 803                                 avg += frameLengthInMS;
 804                         }
 805
 806                         avg /= (toFrameIdx - fromFrameIdx + 1);
 807                 }
 808
 809                 public void GetFrameGroupData(int fromFrameIdx, int toFrameIdx, String[] groups, GroupsStats stats)
 810                 {
 811                         for (int i = fromFrameIdx; i <= toFrameIdx; i++)
 812                         {
 813                                 FrameRecord fr = FrameRecords[i];
 814
 815                                 foreach (string key in fr.Values.Paths)
 816                                 {
 817                                         foreach (string group in groups)
 818                                         {
 819                                                 if (key.Contains(group))
 820                                                 {
 821                                                         if (stats.m_groupStats.Count == 0 || !stats.ContainsGroup(group))
 822                                                         {
 823                                                                 stats.m_groupStats.Add(group, new GroupItemStats());
 824                                                         }
 825
 826                                                         GroupItemStats groupItemStats = stats.GetGroupItemsStats(group);
 827
 828                                                         string itemKey = key.Substring(key.LastIndexOf('/') + 1);
 829
 830                                                         if (!groupItemStats.ContainsItem(itemKey))
 831                                                         {
 832                                                                 groupItemStats.m_groupItemStats.Add(itemKey, new Stats());
 833                                                         }
 834
 835                                                         Stats itemStats = groupItemStats.GetItemStats(itemKey);
 836                                                         itemStats.m_min = Math.Min(itemStats.m_min, fr.Values[key]);
 837                                                         itemStats.m_max = Math.Max(itemStats.m_max, fr.Values[key]);
 838                                                         itemStats.m_avg += fr.Values[key];
 839                                                 }
 840                                         }
 841                                 }
 842                         }
 843
 844                         foreach (string group in stats.m_groupStats.Keys)
 845                         {
 846                                 foreach (string item in stats.GetGroupItemsStats(group).m_groupItemStats.Keys)
 847                                 {
 848                                         Stats itemStats = stats.GetGroupItemsStats(group).GetItemStats(item);
 849                                         itemStats.m_avg /= (toFrameIdx - fromFrameIdx + 1);
 850                                 }
 851                         }
 852                 }
 853
 854                 public float GetPercentileValue(GetRecordValue grv, float percentile)
 855                 {
 856                         List<float> values = new List<float>();
 857
 858                         foreach (FrameRecord fr in FrameRecords)
 859                         {
 860                                 values.Add(grv(fr));
 861                         }
 862
 863                         values.Sort();
 864
 865                         return values[(int)((values.Count - 1) * percentile / 100.0f)];
 866                 }
 867
 868                 public void CalculateLevelRanges()
 869                 {
 870                         FrameRecord startFR = null;
 871                         string levelName = "unknown_level_name";
 872
 873                         foreach (FrameRecord fr in FrameRecords)
 874                         {
 875                                 foreach (UserMarkerLocation userMarkerLoc in fr.UserMarkers)
 876                                 {
 877                                         if (userMarkerLoc.IsLevelStart())
 878                                         {
 879                                                 if (startFR != null)
 880                                                 {
 881                                                         Console.WriteLine("Level start marker found (level name: '" + levelName + "') before previous end!");
 882                                                 }
 883
 884                                                 startFR = fr;
 885                                                 levelName = userMarkerLoc.GetLevelName().Replace("/", " - ");   // confluence doesn't like /
 886                                         }
 887                                         else if (userMarkerLoc.IsLevelEnd())
 888                                         {
 889                                                 if (startFR != null)
 890                                                 {
 891                                                         m_levelRanges.Add(new FrameRecordRange(levelName, startFR.Index, fr.Index));
 892                                                         startFR = null;
 893                                                 }
 894                                                 else
 895                                                 {
 896                                                         Console.WriteLine("Level end marker, but no start!");
 897                                                 }
 898                                         }
 899                                 }
 900                         }
 901
 902                         if (startFR != null)
 903                         {
 904                                 // if there's a start with no end, use the end of the log as the range end
 905                                 m_levelRanges.Add(new FrameRecordRange(levelName, startFR.Index, FrameRecords.Count - 1));
 906                         }
 907                 }
 908
 909                 public void SetItemMetaData(string path, EItemType type)
 910                 {
 911                         if (ItemMetaData.ContainsKey(path))
 912                         {
 913                                 if (ItemMetaData[path].m_type != type)
 914                                 {
 915                                         throw new Exception(string.Format("'{0}' type has changed: was {1}, now {2}", path, ItemMetaData[path].m_type, type));
 916                                 }
 917                         }
 918                         else
 919                         {
 920                                 ItemMetaData[path] = new ItemMetaData(type);
 921                         }
 922                 }
 923         }
 924
 925         public class BuildInfo
 926         {
 927                 public readonly string PlatformString;
 928                 public readonly string BuildNumberString;
 929
 930                 public BuildInfo(string filename)
 931                 {
 932                         Regex regex = new Regex("perflog_(?<platform>\\w*)_(?<buildNum_3>[0-9]*)_(?<buildNum_2>[0-9]*)_(?<buildNum_1>[0-9]*)_(?<buildNum_0>[0-9]*).*.log");
 933                         Match match = regex.Match(filename);
 934
 935                         if (match.Success)
 936                         {
 937                                 PlatformString = match.Groups["platform"].Value;
 938                                 BuildNumberString = match.Groups["buildNum_3"].Value + "." +
 939                                                     match.Groups["buildNum_2"].Value + "." +
 940                                                     match.Groups["buildNum_1"].Value + "." +
 941                                                     match.Groups["buildNum_0"].Value;
 942                         }
 943                         else
 944                         {
 945                                 PlatformString = "<unknown platform>";
 946                                 BuildNumberString = "<unknown build number>";
 947                         }
 948                 }
 949         }
 950 }