playtest-unity/playtest/Library/PackageCache/com.unity.performance.profi.../Editor/ProfileAnalysis.cs

406 lines
15 KiB
C#

using System;
using System.Collections.Generic;
using UnityEngine;
namespace UnityEditor.Performance.ProfileAnalyzer
{
[Serializable]
internal class ProfileAnalysis
{
FrameSummary m_FrameSummary = new FrameSummary();
List<MarkerData> m_Markers = new List<MarkerData>();
List<ThreadData> m_Threads = new List<ThreadData>();
public ProfileAnalysis()
{
m_FrameSummary.first = 0;
m_FrameSummary.last = 0;
m_FrameSummary.count = 0;
m_FrameSummary.msTotal = 0.0;
m_FrameSummary.msMin = float.MaxValue;
m_FrameSummary.msMax = 0.0f;
m_FrameSummary.minFrameIndex = 0;
m_FrameSummary.maxFrameIndex = 0;
m_FrameSummary.maxMarkerDepth = 0;
m_FrameSummary.totalMarkers = 0;
m_FrameSummary.markerCountMax = 0;
m_FrameSummary.markerCountMaxMean = 0.0f;
for (int b = 0; b < m_FrameSummary.buckets.Length; b++)
m_FrameSummary.buckets[b] = 0;
m_Markers.Clear();
m_Threads.Clear();
}
public void SetRange(int firstFrameIndex, int lastFrameIndex)
{
m_FrameSummary.first = firstFrameIndex;
m_FrameSummary.last = lastFrameIndex;
// Ensure these are initialized to frame indices within the range
m_FrameSummary.minFrameIndex = firstFrameIndex;
// if this wasn't initialized, and all frames had 0 length, it wouldn't be set in the UpdateSummary step of the analysis and point out of range
m_FrameSummary.maxFrameIndex = firstFrameIndex;
}
public void AddMarker(MarkerData marker)
{
m_Markers.Add(marker);
}
public void AddThread(ThreadData thread)
{
m_Threads.Add(thread);
}
public void UpdateSummary(int frameIndex, float msFrame)
{
m_FrameSummary.msTotal += msFrame;
m_FrameSummary.count += 1;
if (msFrame < m_FrameSummary.msMin)
{
m_FrameSummary.msMin = msFrame;
m_FrameSummary.minFrameIndex = frameIndex;
}
if (msFrame > m_FrameSummary.msMax)
{
m_FrameSummary.msMax = msFrame;
m_FrameSummary.maxFrameIndex = frameIndex;
}
m_FrameSummary.frames.Add(new FrameTime(frameIndex, msFrame, 1));
}
FrameTime GetPercentageOffset(List<FrameTime> frames, float percent, out int outputFrameIndex)
{
int index = (int)((frames.Count - 1) * percent / 100);
outputFrameIndex = frames[index].frameIndex;
// True median is half of the sum of the middle 2 frames for an even count. However this would be a value never recorded so we avoid that.
return frames[index];
}
float GetThreadPercentageOffset(List<ThreadFrameTime> frames, float percent, out int outputFrameIndex)
{
int index = (int)((frames.Count - 1) * percent / 100);
outputFrameIndex = frames[index].frameIndex;
// True median is half of the sum of the middle 2 frames for an even count. However this would be a value never recorded so we avoid that.
return frames[index].ms;
}
void CalculateStandardDeviations(MarkerData marker)
{
if (marker.frames.Count <= 1)
{
marker.msStandardDeviation = 0;
marker.countStandardDeviation = 0;
return;
}
int frameCount = marker.frames.Count;
float msMean = marker.msMean;
float countMean = marker.countMean;
double msSum = 0.0;
double countSum = 0.0;
for (int i = 0; i < frameCount; ++i)
{
float delta = (marker.frames[i].ms - msMean);
msSum += (delta * delta);
delta = (marker.frames[i].count - countMean);
countSum += (delta * delta);
}
double variance = msSum / (frameCount - 1);
marker.msStandardDeviation = (float)Math.Sqrt(variance);
variance = countSum / (frameCount - 1);
marker.countStandardDeviation = (float)Math.Sqrt(variance);
}
public void SetupMarkers()
{
int countMax = 0;
float countMaxMean = 0.0f;
foreach (MarkerData marker in m_Markers)
{
marker.msAtMedian = 0.0f;
marker.msMin = float.MaxValue;
marker.msMax = float.MinValue;
marker.minFrameIndex = 0;
marker.maxFrameIndex = 0;
marker.countMin = int.MaxValue;
marker.countMax = int.MinValue;
foreach (FrameTime frameTime in marker.frames)
{
var ms = frameTime.ms;
int frameIndex = frameTime.frameIndex;
// Total time for marker over frame
if (ms < marker.msMin)
{
marker.msMin = ms;
marker.minFrameIndex = frameIndex;
}
if (ms > marker.msMax)
{
marker.msMax = ms;
marker.maxFrameIndex = frameIndex;
}
if (frameIndex == m_FrameSummary.medianFrameIndex)
marker.msAtMedian = ms;
var count = frameTime.count;
// count for marker over frame
if (count < marker.countMin)
{
marker.countMin = count;
}
if (count > marker.countMax)
{
marker.countMax = count;
}
}
int unusedIndex;
marker.msMean = marker.presentOnFrameCount > 0 ? (float)(marker.msTotal / marker.presentOnFrameCount) : 0f;
marker.frames.Sort(FrameTime.CompareCount);
marker.countMedian = GetPercentageOffset(marker.frames, 50, out marker.medianFrameIndex).count;
marker.countLowerQuartile = GetPercentageOffset(marker.frames, 25, out unusedIndex).count;
marker.countUpperQuartile = GetPercentageOffset(marker.frames, 75, out unusedIndex).count;
marker.countMean = marker.presentOnFrameCount > 0 ? (float)marker.count / marker.presentOnFrameCount : 0f;
marker.frames.Sort(FrameTime.CompareMs);
marker.msMedian = GetPercentageOffset(marker.frames, 50, out marker.medianFrameIndex).ms;
marker.msLowerQuartile = GetPercentageOffset(marker.frames, 25, out unusedIndex).ms;
marker.msUpperQuartile = GetPercentageOffset(marker.frames, 75, out unusedIndex).ms;
CalculateStandardDeviations(marker);
if (marker.countMax > countMax)
countMax = marker.countMax;
if (marker.countMean > countMaxMean)
countMaxMean = marker.countMean;
}
m_FrameSummary.markerCountMax = countMax;
m_FrameSummary.markerCountMaxMean = countMaxMean;
}
public void SetupMarkerBuckets()
{
// using a for loop instead of foreach is surprisingly faster on Mono
for (int i = 0, n = m_Markers.Count; i < n; i++)
{
var marker = m_Markers[i];
marker.ComputeBuckets(marker.msMin, marker.msMax);
marker.ComputeCountBuckets(marker.countMin, marker.countMax);
}
}
public void SetupFrameBuckets(float timeScaleMax)
{
float first = 0;
float last = timeScaleMax;
float range = last - first;
int maxBucketIndex = m_FrameSummary.buckets.Length - 1;
for (int bucketIndex = 0; bucketIndex < m_FrameSummary.buckets.Length; bucketIndex++)
{
m_FrameSummary.buckets[bucketIndex] = 0;
}
float scale = range > 0 ? m_FrameSummary.buckets.Length / range : 0;
// using a for loop instead of foreach is surprisingly faster on Mono
for (int i = 0, n = m_FrameSummary.frames.Count; i < n; i++)
{
var frameData = m_FrameSummary.frames[i];
var msFrame = frameData.ms;
//var frameIndex = frameData.frameIndex;
int bucketIndex = (int)((msFrame - first) * scale);
if (bucketIndex < 0 || bucketIndex > maxBucketIndex)
{
// It can occur for the highest entry in the range (max-min/range) = 1
// if (ms > max) // Check for the spilling case
// Debug.Log(string.Format("Frame {0}ms exceeds range {1}-{2} on frame {3}", msFrame, first, last, frameIndex));
if (bucketIndex > maxBucketIndex)
bucketIndex = maxBucketIndex;
else
bucketIndex = 0;
}
m_FrameSummary.buckets[bucketIndex] += 1;
}
if (range == 0)
{
// All buckets will be the same
for (int bucketIndex = 1; bucketIndex < m_FrameSummary.buckets.Length; bucketIndex++)
{
m_FrameSummary.buckets[bucketIndex] = m_FrameSummary.buckets[0];
}
}
}
void CalculateThreadMedians()
{
foreach (var thread in m_Threads)
{
if (thread.frames.Count > 0)
{
thread.frames.Sort();
int unusedIndex;
thread.msMin = GetThreadPercentageOffset(thread.frames, 0, out thread.minFrameIndex);
thread.msLowerQuartile = GetThreadPercentageOffset(thread.frames, 25, out unusedIndex);
thread.msMedian = GetThreadPercentageOffset(thread.frames, 50, out thread.medianFrameIndex);
thread.msUpperQuartile = GetThreadPercentageOffset(thread.frames, 75, out unusedIndex);
thread.msMax = GetThreadPercentageOffset(thread.frames, 100, out thread.maxFrameIndex);
// Put back in order of frames
thread.frames.Sort((a, b) => a.frameIndex.CompareTo(b.frameIndex));
}
else
{
thread.msMin = 0f;
thread.msLowerQuartile = 0f;
thread.msMedian = 0f;
thread.msUpperQuartile = 0f;
thread.msMax = 0f;
}
}
}
public void Finalise(float timeScaleMax, int maxMarkerDepth)
{
if (m_FrameSummary.frames.Count > 0)
{
m_FrameSummary.frames.Sort();
m_FrameSummary.msMean = (float)(m_FrameSummary.msTotal / m_FrameSummary.count);
m_FrameSummary.msMedian = GetPercentageOffset(m_FrameSummary.frames, 50, out m_FrameSummary.medianFrameIndex).ms;
int unusedIndex;
m_FrameSummary.msLowerQuartile = GetPercentageOffset(m_FrameSummary.frames, 25, out unusedIndex).ms;
m_FrameSummary.msUpperQuartile = GetPercentageOffset(m_FrameSummary.frames, 75, out unusedIndex).ms;
}
else
{
m_FrameSummary.msMean = 0f;
m_FrameSummary.msMedian = 0f;
m_FrameSummary.msLowerQuartile = 0f;
m_FrameSummary.msUpperQuartile = 0f;
// This started as float.MaxValue and won't have been updated
m_FrameSummary.msMin = 0f;
}
// No longer need the frame time list ?
//m_frameSummary.msFrame.Clear();
m_FrameSummary.maxMarkerDepth = maxMarkerDepth;
if (timeScaleMax <= 0.0f)
{
// If max frame time range not specified then use the max frame value found.
timeScaleMax = m_FrameSummary.msMax;
}
else if (timeScaleMax < m_FrameSummary.msMax)
{
Debug.Log(string.Format("Expanding timeScaleMax {0} to match max value found {1}", timeScaleMax, m_FrameSummary.msMax));
// If max frame time range too small we must expand it.
timeScaleMax = m_FrameSummary.msMax;
}
SetupMarkers();
SetupMarkerBuckets();
SetupFrameBuckets(timeScaleMax);
// Sort in median order (highest first)
m_Markers.Sort(SortByAtMedian);
CalculateThreadMedians();
}
int SortByAtMedian(MarkerData a, MarkerData b)
{
if (a.msAtMedian == b.msAtMedian)
return -a.medianFrameIndex.CompareTo(b.medianFrameIndex);
return -a.msAtMedian.CompareTo(b.msAtMedian);
}
public List<MarkerData> GetMarkers()
{
return m_Markers;
}
public List<ThreadData> GetThreads()
{
return m_Threads;
}
public ThreadData GetThreadByName(string threadNameWithIndex)
{
foreach (var thread in m_Threads)
{
if (thread.threadNameWithIndex == threadNameWithIndex)
return thread;
}
return null;
}
public FrameSummary GetFrameSummary()
{
return m_FrameSummary;
}
public MarkerData GetMarker(int index)
{
if (index < 0 || index >= m_Markers.Count)
return null;
return m_Markers[index];
}
public int GetMarkerIndexByName(string markerName)
{
if (markerName == null)
return -1;
for (int index = 0; index < m_Markers.Count; index++)
{
var marker = m_Markers[index];
if (marker.name == markerName)
{
return index;
}
}
return -1;
}
public MarkerData GetMarkerByName(string markerName)
{
if (markerName == null)
return null;
for (int index = 0; index < m_Markers.Count; index++)
{
var marker = m_Markers[index];
if (marker.name == markerName)
{
return marker;
}
}
return null;
}
}
}