mirror of
https://github.com/beefytech/Beef.git
synced 2025-06-08 11:38:21 +02:00
755 lines
18 KiB
Beef
755 lines
18 KiB
Beef
using System;
|
|
using Beefy.utils;
|
|
using System.Diagnostics;
|
|
using System.Collections;
|
|
using Beefy.gfx;
|
|
using Beefy.geom;
|
|
using Beefy.theme.dark;
|
|
using Beefy.widgets;
|
|
|
|
namespace IDE.ui
|
|
{
|
|
class DiagnosticsPanel : Panel
|
|
{
|
|
class DbgAllocListViewItem : IDEListViewItem
|
|
{
|
|
public int mTypeId;
|
|
public int mAllocCount;
|
|
public int mAllocSize;
|
|
}
|
|
|
|
class DbgAllocListView : DarkListView
|
|
{
|
|
public this()
|
|
{
|
|
//mShowLineGrid = true;
|
|
}
|
|
|
|
protected override ListViewItem CreateListViewItem()
|
|
{
|
|
return new DbgAllocListViewItem();
|
|
}
|
|
|
|
public override void DrawAll(Graphics g)
|
|
{
|
|
base.DrawAll(g);
|
|
|
|
/*using (g.PushColor(0x40FF0000))
|
|
g.FillRect(8, 8, mWidth - 16, mHeight - 16);*/
|
|
}
|
|
}
|
|
|
|
struct Sample
|
|
{
|
|
public double mValue;
|
|
public double mTime;
|
|
|
|
public this(double value, double time)
|
|
{
|
|
mValue = value;
|
|
mTime = time;
|
|
}
|
|
|
|
public static Sample operator+(Sample lhs, Sample rhs)
|
|
{
|
|
return .(lhs.mValue + rhs.mValue, lhs.mTime + rhs.mTime);
|
|
}
|
|
|
|
public static Sample operator-(Sample lhs, Sample rhs)
|
|
{
|
|
return .(lhs.mValue - rhs.mValue, lhs.mTime - rhs.mTime);
|
|
}
|
|
|
|
public static Sample operator*(Sample lhs, float rhs)
|
|
{
|
|
return .(lhs.mValue * rhs, lhs.mTime * rhs);
|
|
}
|
|
}
|
|
|
|
class Data
|
|
{
|
|
public const int cMaxSamples = 1000;
|
|
public static float[cMaxSamples + 1] sSampleMixTable;
|
|
|
|
static this()
|
|
{
|
|
for (int i < cMaxSamples + 1)
|
|
{
|
|
float pct = (i + 0.1f) / (float)(cMaxSamples - 3);
|
|
pct = Math.Pow(pct, 1.5f);
|
|
sSampleMixTable[i] = pct;
|
|
}
|
|
}
|
|
|
|
public List<double> mSamples = new .() ~ delete _;
|
|
double mPrevSample;
|
|
double mNextSample;
|
|
|
|
public double mMaxValue;
|
|
List<double> mPrevValues = new List<double>() ~ delete _;
|
|
|
|
double mSampleAcc;
|
|
int32 mSampleCount;
|
|
int32 mSampleCombine;
|
|
|
|
public this(int sampleCombine)
|
|
{
|
|
mSampleCombine = (.)sampleCombine;
|
|
}
|
|
|
|
public void AddSample(double sample)
|
|
{
|
|
double insertSample = sample;
|
|
|
|
if (mSampleCombine > 1)
|
|
{
|
|
if (mSamples.IsEmpty)
|
|
{
|
|
mPrevSample = sample;
|
|
mNextSample = sample;
|
|
}
|
|
|
|
mSampleAcc += sample;
|
|
mSampleCount++;
|
|
|
|
insertSample = Math.Lerp(mPrevSample, mNextSample, mSampleCount / (float)mSampleCombine);
|
|
|
|
if (mSampleCount == mSampleCombine)
|
|
{
|
|
mPrevSample = mNextSample;
|
|
mNextSample = mSampleAcc / mSampleCombine;
|
|
mSampleCount = 0;
|
|
mSampleAcc = 0;
|
|
}
|
|
}
|
|
|
|
mSamples.Add(insertSample);
|
|
|
|
mPrevValues.Add(insertSample);
|
|
|
|
mMaxValue = Math.Max(mMaxValue, insertSample);
|
|
|
|
while (mSamples.Count > cMaxSamples)
|
|
{
|
|
for (int sampleIdx < mSamples.Count - 1)
|
|
{
|
|
let lhs = mSamples[sampleIdx];
|
|
let rhs = mSamples[sampleIdx + 1];
|
|
float pct = sSampleMixTable[sampleIdx];
|
|
mSamples[sampleIdx] = Math.Lerp(lhs, rhs, pct);
|
|
}
|
|
mSamples.PopBack();
|
|
}
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
mMaxValue = 0;
|
|
mSamples.Clear();
|
|
}
|
|
|
|
public float Get(float sampleIdx)
|
|
{
|
|
let lhs = mSamples[(int)sampleIdx];
|
|
let rhs = mSamples[(int)Math.Min(sampleIdx + 1, mSamples.Count - 1)];
|
|
return (.)Math.Lerp(lhs, rhs, sampleIdx - (int)sampleIdx);
|
|
}
|
|
}
|
|
|
|
class DataView : Widget
|
|
{
|
|
public DiagnosticsPanel mPanel;
|
|
public Data mTimes;
|
|
public Data mData;
|
|
public double? mOverDataTime;
|
|
public double? mOverDataValue;
|
|
public String mLabel = new .() ~ delete _;
|
|
|
|
public this(StringView label)
|
|
{
|
|
mLabel.Set(label);
|
|
}
|
|
|
|
[LinkName(.C)]
|
|
public static extern double log10(double val);
|
|
|
|
[LinkName(.C)]
|
|
public static extern double log2(double val);
|
|
|
|
void ValToString(double val, String str)
|
|
{
|
|
let kSize = 1024;
|
|
|
|
let maxValue = mData.mMaxValue;
|
|
if (maxValue < 1000)
|
|
{
|
|
str.AppendF("{:0.00}", val);
|
|
}
|
|
else if (maxValue < 10000)
|
|
{
|
|
str.AppendF("{:0.0}", val);
|
|
}
|
|
else if (maxValue < 1'000'000)
|
|
{
|
|
str.AppendF("{}", (int)val);
|
|
}
|
|
else if (maxValue < 1000 * kSize)
|
|
{
|
|
str.AppendF("{:0.000}K", val / kSize);
|
|
}
|
|
else if (maxValue < 1000 * (kSize * kSize))
|
|
{
|
|
str.AppendF("{:0.000}M", val / (kSize * kSize));
|
|
}
|
|
else
|
|
{
|
|
str.AppendF("{:0.000}G", val / (kSize * kSize * kSize));
|
|
}
|
|
}
|
|
|
|
public void DrawData(Graphics g, Data data, Data timeData, float xOfs, float yOfs, float width, float height)
|
|
{
|
|
|
|
|
|
/*for (double maxValue = 0.001; maxValue < 2; maxValue += 0.001)
|
|
{
|
|
double segLog10 = log10(maxValue);
|
|
if (segLog10 > 0)
|
|
segLog10 = (int)(segLog10);
|
|
double segSize = Math.Pow(10, segLog10);
|
|
double numSegs = maxValue / segSize;
|
|
if (numSegs < 2)
|
|
segSize /= 4;
|
|
else if (numSegs < 4)
|
|
segSize /= 2;
|
|
numSegs = maxValue / segSize;
|
|
|
|
Debug.WriteLine("{} {:.00} {:.00}", maxValue, segSize, numSegs);
|
|
}*/
|
|
|
|
/*while (true)
|
|
{
|
|
double numSegs = maxValue / segSize;
|
|
if (numSegs >= 3)
|
|
break;
|
|
}*/
|
|
|
|
|
|
|
|
using (g.PushTranslate(xOfs, yOfs))
|
|
{
|
|
using (g.PushColor(0xA0000000))
|
|
{
|
|
g.FillRect(0, 0, width, height);
|
|
}
|
|
|
|
using (g.PushColor(0x40FFFFFF))
|
|
{
|
|
g.OutlineRect(-1, -1, width + 2, height + 2);
|
|
}
|
|
|
|
if (data.mSamples.IsEmpty)
|
|
return;
|
|
|
|
if (data.mMaxValue > 0)
|
|
{
|
|
using (g.PushClip(0, 0, width, height))
|
|
{
|
|
using (g.PushColor(0xFF00FF00))
|
|
{
|
|
float prevY = 0;
|
|
|
|
for (int x < (int)width)
|
|
{
|
|
float sampleIdx = x * (data.mSamples.Count - 1) / width;
|
|
float value = data.Get(sampleIdx);
|
|
|
|
float y = (.)(height * (1.0 - (value / data.mMaxValue)) + 0.5);
|
|
|
|
if (x == 0)
|
|
g.FillRect(x, y, 1, 1);
|
|
else if (y > prevY)
|
|
g.FillRect(x, prevY, 1, y - prevY + 1);
|
|
else
|
|
g.FillRect(x, y, 1, prevY - y + 1);
|
|
|
|
prevY = y;
|
|
}
|
|
}
|
|
}
|
|
|
|
float labelX = 0;
|
|
float labelWidth = 0;
|
|
|
|
g.SetFont(DarkTheme.sDarkTheme.mSmallFont);
|
|
int[?] times = .(5, 15, 60, 5*60, 15*60);
|
|
int findIdx = 0;
|
|
int findTime = times[0];
|
|
double prevTime = mPanel.mCurTimeSecs;
|
|
|
|
bool wantOverTime = mOverDataTime != null;
|
|
|
|
bool drawLabels = width > GS!(240);
|
|
for (int idx = data.mSamples.Count - 1; idx >= 0; idx--)
|
|
{
|
|
double checkTime = timeData.mSamples[idx];
|
|
|
|
if ((wantOverTime) && (checkTime <= mOverDataTime))
|
|
{
|
|
wantOverTime = false;
|
|
|
|
//float x = idx + (float)((findTime - checkTime) / (prevTime - checkTime));
|
|
|
|
float overIdx = idx; // + (float)((mOverDataTime - checkTime) / (prevTime - checkTime));
|
|
|
|
float x = (int)((overIdx / (float)(data.mSamples.Count - 1)) * width);
|
|
|
|
double value = mOverDataValue.Value;
|
|
g.SetFont(DarkTheme.sDarkTheme.mSmallBoldFont);
|
|
|
|
int deltaSecs = (int)(mPanel.mCurTimeSecs - mOverDataTime.Value);
|
|
|
|
String drawStr = scope .();
|
|
ValToString(value, drawStr);
|
|
drawStr.AppendF(" at {}:{:00}", deltaSecs / 60, deltaSecs % 60);
|
|
|
|
labelWidth = g.mFont.GetWidth(drawStr);
|
|
|
|
labelX = Math.Clamp(x, labelWidth / 2, width - labelWidth / 2);
|
|
|
|
g.DrawString(drawStr, labelX, -GS!(19), .Centered);
|
|
|
|
using (g.PushColor(0x70FFFFFF))
|
|
g.FillRect(x, 0, 1, height);
|
|
}
|
|
|
|
double timeDif = mPanel.mCurTimeSecs - checkTime;
|
|
if (timeDif >= findTime)
|
|
{
|
|
double prevTimeDif = mPanel.mCurTimeSecs - prevTime;
|
|
float addIdx = idx + (float)((timeDif - findTime) / (timeDif - prevTimeDif));
|
|
|
|
float x = (int)((addIdx / (data.mSamples.Count - 1)) * width);
|
|
|
|
using (g.PushColor(0xA0FFFFFF))
|
|
g.FillRect(x, 0, 1, height);
|
|
|
|
if (drawLabels)
|
|
{
|
|
uint32 color = 0xFFFFFFFF;
|
|
if (Math.Abs(x - labelX) < labelWidth / 2 + GS!(20))
|
|
color = 0x60FFFFFF;
|
|
using (g.PushColor(color))
|
|
g.DrawString(scope String()..AppendF("{}:{:00}", findTime / 60, findTime % 60), x + GS!(2), -GS!(20), .Centered);
|
|
}
|
|
|
|
if (++findIdx >= times.Count)
|
|
break;
|
|
findTime = times[findIdx];
|
|
}
|
|
|
|
prevTime = checkTime;
|
|
}
|
|
}
|
|
|
|
// Draw segments
|
|
|
|
double maxValue = mData.mMaxValue;
|
|
double segLog10 = log10(maxValue);
|
|
if (segLog10 > 0)
|
|
segLog10 = (int)(segLog10);
|
|
double segSize = Math.Pow(10, segLog10);
|
|
|
|
if (maxValue >= 1'000'000)
|
|
{
|
|
double segLog2 = log2(maxValue);
|
|
segLog2 = (int)(segLog2);
|
|
segSize = Math.Pow(2, segLog2);
|
|
}
|
|
|
|
double numSegs = maxValue / segSize;
|
|
|
|
|
|
if (numSegs < 2)
|
|
segSize /= 4;
|
|
else if (numSegs < 4)
|
|
segSize /= 2;
|
|
|
|
/*int kSize = 1024;
|
|
if (segSize >= kSize * kSize * kSize)
|
|
segSize = (int)(segSize / (kSize * kSize * kSize)) * (kSize * kSize * kSize);
|
|
else if (segSize >= kSize * kSize)
|
|
segSize = (int)(segSize / (kSize * kSize)) * (kSize * kSize);
|
|
else if (segSize >= kSize)
|
|
segSize = (int)(segSize / (kSize)) * (kSize);*/
|
|
|
|
numSegs = (int)(maxValue / segSize + 0.95f);
|
|
|
|
g.SetFont(DarkTheme.sDarkTheme.mSmallFont);
|
|
for (int segIdx = 1; segIdx < (int)numSegs; segIdx++)
|
|
{
|
|
bool drawLabels = width > GS!(120);
|
|
double segValue = segIdx * segSize;
|
|
|
|
float drawY = (int)((1 - segValue / maxValue) * (height - 1));
|
|
using (g.PushColor(0x40FFFFFF))
|
|
g.FillRect(0, drawY, width, 1);
|
|
if (drawLabels)
|
|
{
|
|
var labelStr = scope String();
|
|
ValToString(segValue, labelStr);
|
|
g.DrawString(labelStr, -xOfs, drawY - GS!(10), .Right, xOfs - GS!(4));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Rect GetDataRect()
|
|
{
|
|
return .(GS!(80), GS!(20), mWidth - GS!(80) - 2, mHeight - GS!(20) - 2);
|
|
}
|
|
|
|
public override void MouseLeave()
|
|
{
|
|
base.MouseLeave();
|
|
mOverDataTime = null;
|
|
}
|
|
|
|
public override void MouseMove(float x, float y)
|
|
{
|
|
base.MouseMove(x, y);
|
|
|
|
let dataRect = GetDataRect();
|
|
if ((x >= dataRect.mX) && (x < dataRect.Right) && (!mData.mSamples.IsEmpty))
|
|
{
|
|
float overDataIdx = (x - dataRect.mX) / (float)dataRect.mWidth * mData.mSamples.Count;
|
|
mOverDataTime = mTimes.Get(overDataIdx);
|
|
mOverDataValue = mData.Get(overDataIdx);
|
|
}
|
|
else
|
|
mOverDataTime = null;
|
|
}
|
|
|
|
public override void Draw(Graphics g)
|
|
{
|
|
base.Draw(g);
|
|
|
|
let dataRect = GetDataRect();
|
|
|
|
using (g.PushColor(0x20FFFFFF))
|
|
g.FillRect(0, 0, mWidth, mHeight);
|
|
|
|
DrawData(g, mData, mTimes, dataRect.mX, dataRect.mY, dataRect.mWidth, dataRect.mHeight);
|
|
|
|
g.SetFont(DarkTheme.sDarkTheme.mSmallBoldFont);
|
|
g.DrawString(mLabel, -GS!(0), -GS!(0), .Centered, dataRect.mX);
|
|
}
|
|
}
|
|
|
|
#region fields
|
|
ScrollableWidget mScrollableWidget;
|
|
Widget mContentWidget;
|
|
|
|
Stopwatch mSampleStopwatch = new .() ~ delete _;
|
|
int mSampleCPUTime;
|
|
double mCurTimeSecs;
|
|
|
|
const int cMaxSamples = 1024;
|
|
Data mRunningTime = new .(0) ~ delete _;
|
|
Data mUserTime = new .(6) ~ delete _;
|
|
Data mWorkingMem = new .(0) ~ delete _;
|
|
Data mVirtualMem = new .(0) ~ delete _;
|
|
Data mDbgAllocMem = new .(0) ~ delete _;
|
|
|
|
List<DataView> mDataViews = new List<DataView>() ~ delete _;
|
|
DbgAllocListView mDbgAllocListView;
|
|
DarkButton mRefreshButton;
|
|
|
|
public this()
|
|
{
|
|
mSampleStopwatch.Start();
|
|
/*for (int i < 10)
|
|
AddSample(mUserTime, .(i, i));*/
|
|
|
|
mScrollableWidget = new ScrollableWidget();
|
|
mScrollableWidget.InitScrollbars(false, true);
|
|
AddWidget(mScrollableWidget);
|
|
|
|
mContentWidget = new Widget();
|
|
mScrollableWidget.mScrollContentContainer.AddWidget(mContentWidget);
|
|
mScrollableWidget.mScrollContent = mContentWidget;
|
|
|
|
DataView dataView = new DataView("CPU");
|
|
dataView.mPanel = this;
|
|
dataView.mTimes = mRunningTime;
|
|
dataView.mData = mUserTime;
|
|
mContentWidget.AddWidget(dataView);
|
|
mDataViews.Add(dataView);
|
|
|
|
dataView = new DataView("VMem");
|
|
dataView.mPanel = this;
|
|
dataView.mTimes = mRunningTime;
|
|
dataView.mData = mVirtualMem;
|
|
mContentWidget.AddWidget(dataView);
|
|
mDataViews.Add(dataView);
|
|
|
|
dataView = new DataView("WkMem");
|
|
dataView.mPanel = this;
|
|
dataView.mTimes = mRunningTime;
|
|
dataView.mData = mWorkingMem;
|
|
mContentWidget.AddWidget(dataView);
|
|
mDataViews.Add(dataView);
|
|
|
|
dataView = new DataView("DbgAlloc");
|
|
dataView.mPanel = this;
|
|
dataView.mTimes = mRunningTime;
|
|
dataView.mData = mDbgAllocMem;
|
|
mContentWidget.AddWidget(dataView);
|
|
mDataViews.Add(dataView);
|
|
|
|
mRefreshButton = new DarkButton();
|
|
mRefreshButton.Label = "Get Debug Alloc Information";
|
|
mRefreshButton.mOnMouseClick.Add(new (mouseArgs) =>
|
|
{
|
|
if (gApp.mDebugger.mIsRunning)
|
|
{
|
|
var info = scope String();
|
|
//let sampler = Profiler.StartSampling().GetValueOrDefault();
|
|
gApp.mDebugger.GetDbgAllocInfo(info);
|
|
/*if (sampler != default)
|
|
sampler.Dispose();*/
|
|
|
|
PopulateDbgAllocInfo(info);
|
|
}
|
|
});
|
|
mContentWidget.AddWidget(mRefreshButton);
|
|
|
|
mDbgAllocListView = new DbgAllocListView();
|
|
|
|
ListViewColumn column = mDbgAllocListView.AddColumn(300, "Type");
|
|
column.mMinWidth = 100;
|
|
|
|
column = mDbgAllocListView.AddColumn(80, "Count");
|
|
column.mMinWidth = 60;
|
|
column = mDbgAllocListView.AddColumn(80, "Size");
|
|
column.mMinWidth = 60;
|
|
|
|
mDbgAllocListView.mOnItemMouseDown.Add(new => ListViewItemMouseDown);
|
|
mDbgAllocListView.mOnItemMouseClicked.Add(new => ListViewItemMouseClicked);
|
|
mDbgAllocListView.mOnKeyDown.Add(new => ListViewKeyDown_ShowMenu);
|
|
|
|
mContentWidget.AddWidget(mDbgAllocListView);
|
|
|
|
ResizeComponents();
|
|
}
|
|
|
|
void Clear()
|
|
{
|
|
mSampleCPUTime = 0;
|
|
mCurTimeSecs = 0;
|
|
mUserTime.Clear();
|
|
mRunningTime.Clear();
|
|
mVirtualMem.Clear();
|
|
mWorkingMem.Clear();
|
|
mDbgAllocMem.Clear();
|
|
mDbgAllocListView.GetRoot().Clear();
|
|
}
|
|
|
|
void ResizeComponents()
|
|
{
|
|
mScrollableWidget.Resize(0, 0, mWidth, mHeight);
|
|
|
|
float width = Math.Max(mScrollableWidget.mWidth - GS!(20), 0);
|
|
|
|
float dataViewWidth = Math.Max((width - GS!(24)) / 2, 100);
|
|
float dataViewHeight = (int)(dataViewWidth * 0.5f);
|
|
|
|
for (let dataView in mDataViews)
|
|
{
|
|
int col = @dataView.Index % 2;
|
|
int row = @dataView.Index / 2;
|
|
|
|
|
|
dataView.Resize(col * (dataViewWidth + GS!(8)) + GS!(8), row * (dataViewHeight + GS!(8)) + GS!(8), dataViewWidth, dataViewHeight);
|
|
}
|
|
|
|
float curY = dataViewHeight * 2 + GS!(24);
|
|
|
|
mRefreshButton.Resize(GS!(8), curY, GS!(240), GS!(20));
|
|
mDbgAllocListView.Resize(GS!(0), curY + GS!(20), Math.Max(width - GS!(0), 120), mDbgAllocListView.mScrollContent.mHeight + GS!(28));
|
|
|
|
mContentWidget.Resize(0, 0, width, curY + mDbgAllocListView.mScrollContent.mHeight + GS!(48));
|
|
mScrollableWidget.UpdateScrollbars();
|
|
mScrollableWidget.UpdateContentPosition();
|
|
}
|
|
|
|
void PopulateDbgAllocInfo(String info)
|
|
{
|
|
//Debug.WriteLine(info);
|
|
|
|
mDbgAllocListView.GetRoot().Clear();
|
|
|
|
String totalLabel = "Total Debug Allocations";
|
|
|
|
int totalSize = 0;
|
|
int totalCount = 0;
|
|
|
|
DbgAllocListViewItem AddItem(StringView label, int allocCount, int allocSize)
|
|
{
|
|
var newItem = (DbgAllocListViewItem)mDbgAllocListView.GetRoot().CreateChildItem();
|
|
newItem.mAllocCount = allocCount;
|
|
newItem.mAllocSize = allocSize;
|
|
newItem.Label = label;
|
|
|
|
var subItem = newItem.GetOrCreateSubItem(1);
|
|
subItem.Label = scope String()..AppendF("{}", allocCount);
|
|
|
|
subItem = newItem.GetOrCreateSubItem(2);
|
|
subItem.Label = scope String()..AppendF("{}k", (allocSize + 1023)/1024);
|
|
return newItem;
|
|
}
|
|
|
|
for (let line in info.Split('\n'))
|
|
{
|
|
var elemItr = line.Split('\t');
|
|
switch (elemItr.GetNext().Value)
|
|
{
|
|
case "type":
|
|
int typeId = int.Parse(elemItr.GetNext().Value).Value;
|
|
StringView name = elemItr.GetNext().Value;
|
|
int allocCount = int.Parse(elemItr.GetNext().Value).Value;
|
|
int allocSize = int.Parse(elemItr.GetNext().Value).Value;
|
|
|
|
totalCount += allocCount;
|
|
totalSize += allocSize;
|
|
|
|
var newItem = AddItem(name, allocCount, allocSize);
|
|
newItem.mTypeId = typeId;
|
|
//newItem.MakeParent();
|
|
}
|
|
}
|
|
|
|
AddItem(totalLabel, totalCount, totalSize);
|
|
|
|
mDbgAllocListView.GetRoot().mChildItems.Sort(scope (lhs, rhs) =>
|
|
{
|
|
return ((DbgAllocListViewItem)rhs).mAllocSize <=> ((DbgAllocListViewItem)lhs).mAllocSize;
|
|
});
|
|
mDbgAllocListView.GetRoot().ResizeComponents(0);
|
|
mDbgAllocListView.mAutoFocus = true;
|
|
mDbgAllocListView.mOnLostFocus.Add(new (evt) =>
|
|
{
|
|
if (!mShowingRightClickMenu)
|
|
mDbgAllocListView.GetRoot().SelectItemExclusively(null);
|
|
});
|
|
|
|
mDbgAllocListView.UpdateListSize();
|
|
ResizeComponents();
|
|
}
|
|
|
|
public override void Draw(Graphics g)
|
|
{
|
|
base.Draw(g);
|
|
|
|
}
|
|
|
|
public void UpdateStats()
|
|
{
|
|
/*int addIdx = mUpdateCnt;
|
|
AddSample(mUserTime, .(addIdx, addIdx));*/
|
|
|
|
scope AutoBeefPerf("DiagnosticsPanel.UpdateStats");
|
|
|
|
String procInfo = scope .();
|
|
gApp.mDebugger.GetProcessInfo(procInfo);
|
|
|
|
if (gApp.mDebugger.IsPaused())
|
|
{
|
|
mSampleStopwatch.Restart();
|
|
return;
|
|
}
|
|
|
|
if (procInfo.IsEmpty)
|
|
{
|
|
Clear();
|
|
return;
|
|
}
|
|
|
|
if (gApp.mUpdateCnt % 5 != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MarkDirty();
|
|
if (mSampleStopwatch.ElapsedMilliseconds < 10)
|
|
return;
|
|
|
|
// 5 Hz sample rate
|
|
/*if (elapsedTime < 100)
|
|
return;*/
|
|
mSampleStopwatch.Restart();
|
|
|
|
int runningTime = 0;
|
|
int virtualMem = 0;
|
|
int workingMem = 0;
|
|
int kernelTime = 0;
|
|
int userTime = 0;
|
|
|
|
for (let line in procInfo.Split('\n'))
|
|
{
|
|
if (line.IsEmpty)
|
|
break;
|
|
|
|
var lineEnum = line.Split('\t');
|
|
let category = lineEnum.GetNext().Value;
|
|
let valueSV = lineEnum.GetNext().Value;
|
|
let value = int64.Parse(valueSV).Value;
|
|
|
|
switch (category)
|
|
{
|
|
case "WorkingMemory": workingMem = value;
|
|
case "VirtualMemory": virtualMem = value;
|
|
case "RunningTime": runningTime = value;
|
|
case "KernelTime": kernelTime = value;
|
|
case "UserTime": userTime = value;
|
|
}
|
|
}
|
|
|
|
int cpuTime = kernelTime + userTime;
|
|
|
|
double newTimeSecs = runningTime / (double)(10*1000*1000);
|
|
double elapsedTime = newTimeSecs - mCurTimeSecs;
|
|
|
|
mCurTimeSecs = newTimeSecs;
|
|
|
|
mRunningTime.AddSample(mCurTimeSecs);
|
|
mUserTime.AddSample((cpuTime - mSampleCPUTime) * 100 / elapsedTime / 10000000.0f);
|
|
mWorkingMem.AddSample(workingMem);
|
|
mVirtualMem.AddSample(virtualMem);
|
|
mDbgAllocMem.AddSample(gApp.mDebugger.GetDbgAllocHeapSize());
|
|
|
|
mSampleCPUTime = cpuTime;
|
|
|
|
/*int addIdx = mUpdateCnt;
|
|
AddSample(mUserTime, .(addIdx, addIdx));*/
|
|
}
|
|
|
|
public override void Update()
|
|
{
|
|
base.Update();
|
|
}
|
|
|
|
public override void Resize(float x, float y, float width, float height)
|
|
{
|
|
base.Resize(x, y, width, height);
|
|
ResizeComponents();
|
|
}
|
|
|
|
public override void Serialize(StructuredData data)
|
|
{
|
|
base.Serialize(data);
|
|
|
|
data.Add("Type", "DiagnosticsPanel");
|
|
}
|
|
}
|
|
}
|