private void LoadMemOperations(String fileName)
{
Stream s = File.Open(fileName, FileMode.Open);
BinaryFormatter formatter = new BinaryFormatter();
StackTracer.Deserialize(s, formatter);
m_memOperations = formatter.Deserialize(s) as List <MemOperation>;
m_snapshots = formatter.Deserialize(s) as List <SnapshotDesc>;
m_numFrames = (int)formatter.Deserialize(s);
m_mostAllocatedBlocks = formatter.Deserialize(s) as int[];
CallstackTab.m_callStackMap = formatter.Deserialize(s) as Dictionary <ulong, ulong[]>;
TagDict.m_tags = formatter.Deserialize(s) as Dictionary <ulong, string>;
foreach (SnapshotDesc snapDesc in m_snapshots)
{
AddSnapshot(snapDesc.name, snapDesc.bytes, snapDesc.blocks, snapDesc.memOperationNr);
}
s.Close();
m_selectedSnapshotIndex = -1;
m_globalSnapshot = BuildEndSnapshot();
UpdateFrameStats();
SetControlButtonsState(m_numFrames > 0);
m_lastMemOpFrame = -1;
m_lastSnapshotViewFrame = -1;
GoToFrame(0);
}
private MemSnapshot BuildSnapshotForFrame(int frame)
{
MemSnapshot snapshot = new MemSnapshot();
int numOperations = m_memOperations.Count;
int frames = 0;
for (int i = 0; i < numOperations; ++i)
{
MemOperation op = m_memOperations[i];
if (op.OpType == MemOperation.Type.Alloc)
{
snapshot.AddBlock(op.UserData as MemBlock);
}
else if (op.OpType == MemOperation.Type.Free)
{
snapshot.RemoveBlock((ulong)op.UserData);
}
else if (op.OpType == MemOperation.Type.FrameEnd)
{
++frames;
}
if (frames > frame)
{
break;
}
}
m_lastSnapshotViewFrame = frame;
return(snapshot);
}
void BuildTree(MemSnapshot snapshot, int minMemOpNo, int maxMemOpNo)
{
m_tree.Clear();
treeView1.Nodes.Clear();
foreach (MemBlock block in snapshot.Blocks.Values)
{
int memOpNr = MemTracerForm.ms_MainForm.MemOperationNrForBlock(block);
if (memOpNr < maxMemOpNo && memOpNr > minMemOpNo)
{
if (m_detailed)
{
m_tree.AddMemBlockSubTree(block);
}
else
{
m_tree.AddMemBlock(block);
}
}
}
m_tree.Sort();
treeView1.BeginUpdate();
PopulateTreeView(m_tree.Root, treeView1.Nodes);
treeView1.EndUpdate();
m_snapshot = snapshot;
}
MemBlock[] CollectLargestBlocks(MemSnapshot snap, int n)
{
MemBlock[] largestBlocks = new MemBlock[snap.Blocks.Values.Count];
int i = 0;
foreach (MemBlock block in snap.Blocks.Values)
{
largestBlocks[i++] = block;
}
Array.Sort(largestBlocks, new CompareBySize());
/*for (int i = 0; i < largestBlocks.Length; ++i)
* {
* if (largestBlocks[i] != null && largestBlocks[i].m_size == block.m_size)
* break;
*
* if (largestBlocks[i] == null)
* {
* largestBlocks[i] = block;
* break;
* }
* if (largestBlocks[i].m_size < block.m_size)
* {
* for (int j = i + 1; j < largestBlocks.Length; ++j)
* largestBlocks[j] = largestBlocks[j - 1];
* largestBlocks[i] = block;
* break;
* }
* }
* }*/
return(largestBlocks);
}
public MemSnapshot Difference(MemSnapshot other)
{
MemSnapshot ret = new MemSnapshot();
//uint order = 0;
Dictionary <MemBlock, int> usedBlocks = new Dictionary <MemBlock, int>();
foreach (MemBlock otherBlock in other.m_blocks.Values)
{
/*StackTracer.Symbol[] syms = new StackTracer.Symbol[otherBlock.m_callStack.Count];
* for (int i = 0; i < otherBlock.m_callStack.Count; ++i)
* syms[i] = StackTracer.GetSymbolForAddress(otherBlock.m_callStack[i]);*/
bool found = false;
foreach (MemBlock block in m_blocks.Values)
{
if (!usedBlocks.ContainsKey(block) &&
otherBlock.m_size == block.m_size &&
otherBlock.IsCallStackEqual(block))
{
usedBlocks.Add(block, 1);
found = true;
break;
}
}
//otherBlock.m_tag = order;
if (!found)
{
ret.AddBlock(otherBlock);
}
//++order;
}
return(ret);
}
void CompareSnapshots(int snapAIdx, int snapBIdx)
{
MemSnapshot snapA = BuildSnapshotFromDesc(m_snapshots[snapAIdx]);
MemSnapshot snapB = BuildSnapshotFromDesc(m_snapshots[snapBIdx]);
CompareSnapshots dlg = new CompareSnapshots(snapA, snapB, m_snapshots[snapAIdx].name, m_snapshots[snapBIdx].name);
dlg.ShowDialog();
}
void OverlapSnapshots(int snapAIdx, int snapBIdx)
{
MemSnapshot snapA = BuildSnapshotFromDesc(m_snapshots[snapAIdx]);
MemSnapshot snapB = BuildSnapshotFromDesc(m_snapshots[snapBIdx]);
MemSnapshot result = snapA.Overlap(snapB);
ShowSnapshot dlg = new ShowSnapshot(result, "Overlap");
dlg.ShowDialog();
}
public void OnSnapshotSelected(int index)
{
MemSnapshot snap = BuildSnapshotFromDesc(m_snapshots[index]);
snapshotInfo2.Init(m_snapshots[index].name);
snapshotInfo2.Update(snap);
snapshotInfo2.Visible = true;
m_selectedSnapshotIndex = index;
}
public ShowSnapshot(MemSnapshot snap, string name)
{
InitializeComponent();
Text = name;
snapshotInfoControl1.Init(name);
snapshotInfoControl1.Update(snap);
memAllocTree1.BuildTree(snap);
memAllocTree1.SetDoubleClickDelegate(new DelegateDoubleClickNode(DoubleClickNode));
}
public void Update(MemSnapshot snapshot)
{
m_snapshot = snapshot;
uint usedBytes = snapshot.NumAllocatedBytes;
float usedMb = (float)usedBytes / (1024 * 1024);
labelMemUsed.Text = usedMb.ToString("N") + " MB";
float maxUsedMb = (float)snapshot.TopAllocatedBytes / (1024 * 1024);
labelMaxMemUsed.Text = maxUsedMb.ToString("N") + " MB";
labelMaxBlocks.Text = snapshot.TopAllocatedBlocks.ToString();
labelBlocks.Text = snapshot.NumAllocatedBlocks.ToString();
float largestMb = (float)snapshot.LargestAllocation / (1024 * 1024);
labelLargest.Text = largestMb.ToString("N") + " MB";
}
private void tabControl1_Selected(object sender, TabControlEventArgs e)
{
if (e.TabPage == tabPageFrameSnapshot)
{
if (m_frame != m_lastSnapshotViewFrame)
{
MemSnapshot ms = BuildSnapshotForFrame(m_frame);
memAllocTreeFrame.BuildTree(ms);
}
}
else if (e.TabPage == tabPageFrameOps)
{
if (m_frame != m_lastMemOpFrame)
{
memOpTree1.BuildTree(BuildOperationsListForFrame(m_frame));
}
}
}
private void GoToFrame(int frame)
{
if (frameAnalysisToolStripMenuItem.Checked)
{
m_frame = frame;
MemSnapshot ms = BuildSnapshotForFrame(m_frame);
memAllocTreeFrame.BuildTree(ms);
memOpTree1.BuildTree(BuildOperationsListForFrame(m_frame));
toolStripStatusFrame.Text = "Frame: " + m_frame.ToString() + "/" + m_numFrames.ToString();
UpdateUsageGraph((int)ms.NumAllocatedBytes >> 10);
butRewind.Enabled = (m_frame > 0);
butPrevFrame.Enabled = (m_frame > 0);
butFFwd.Enabled = (m_frame < m_numFrames);
butNextFrame.Enabled = (m_frame < m_numFrames);
}
}
public CompareSnapshots(MemSnapshot snapA, MemSnapshot snapB, string nameA, string nameB)
{
InitializeComponent();
snapshotInfoControl1.Init(nameA);
snapshotInfoControl2.Init(nameB);
snapshotInfoControl1.Update(snapA);
snapshotInfoControl2.Update(snapB);
memAllocTree1.BuildTree(snapA);
labelSnap1.Text = nameA;
labelSnap2.Text = nameB;
MemSnapshot diff = snapA.Difference(snapB);
memAllocTree1.BuildTree(snapA);
memAllocTree2.BuildTree(snapB);
memAllocTreeDiff.BuildTree(diff);
}
public void BuildTree(MemSnapshot snapshot)
{
m_tree.Clear();
treeView1.Nodes.Clear();
foreach (MemBlock block in snapshot.Blocks.Values)
{
if (m_detailed)
{
m_tree.AddMemBlockSubTree(block);
}
else
{
m_tree.AddMemBlock(block);
}
}
m_tree.Sort();
treeView1.BeginUpdate();
PopulateTreeView(m_tree.Root, treeView1.Nodes);
treeView1.EndUpdate();
m_snapshot = snapshot;
}
MemSnapshot BuildEndSnapshot()
{
MemSnapshot snapshot = new MemSnapshot();
foreach (MemOperation op in m_memOperations)
{
if (op.OpType == MemOperation.Type.Alloc)
{
snapshot.AddBlock(op.UserData as MemBlock);
}
else if (op.OpType == MemOperation.Type.Free)
{
snapshot.RemoveBlock((ulong)op.UserData);
}
/*else
* {
* int breakh = 1;
* }*/
}
return(snapshot);
}
public MemSnapshot Overlap(MemSnapshot other)
{
MemSnapshot ret = new MemSnapshot();
foreach (MemBlock otherBlock in other.m_blocks.Values)
{
bool found = false;
foreach (MemBlock block in m_blocks.Values)
{
if (otherBlock == block)
{
found = true;
break;
}
}
if (found)
{
ret.AddBlock(otherBlock);
}
}
return(ret);
}
MemSnapshot BuildSnapshotFromDesc(SnapshotDesc desc)
{
MemSnapshot snapshot = new MemSnapshot();
int numOperations = desc.memOperationNr;
if (numOperations > m_memOperations.Count)
{
numOperations = m_memOperations.Count;
}
for (int i = 0; i < numOperations; ++i)
{
MemOperation op = m_memOperations[i];
if (op.OpType == MemOperation.Type.Alloc)
{
snapshot.AddBlock(op.UserData as MemBlock);
}
else if (op.OpType == MemOperation.Type.Free)
{
snapshot.RemoveBlock((ulong)op.UserData);
}
}
return(snapshot);
}
public void BuildTree(MemSnapshot snap)
{
memAllocTree1.BuildTree(snap);
memAllocTree1.ExpandAll();
}
