public static string HeapCellFileName(HeapCell aCell)
{
// Basic filename
string basicName = aCell.Address.ToString("x8");
return(basicName);
}
private void iContents_CellLinkDoubleClicked(HeapCell aCell)
{
if (iMainForm != null)
{
iMainForm.FocusedCell = aCell;
}
}
public override void PopupShowAsyncImpl(HeapCellArrayWithStatistics aCells, HeapStatistics aStats, Point aLocalControlCoordinates, Point aScreenCoordinates, Size aOffsetBy, System.Windows.Forms.KeyEventHandler aKeyHandler)
{
PopupHide();
//
if (aCells.Count == 1)
{
HeapCell cell = aCells[0];
//
switch (cell.Type)
{
default:
case HeapCell.TType.EAllocated:
if (cell.Symbol != null)
{
iActivePopup = new PopupCellAllocatedSymbols();
}
else
{
iActivePopup = new PopupCellAllocatedRaw();
}
break;
case HeapCell.TType.EFree:
iActivePopup = new PopupCellFree();
break;
}
}
else if (aCells.Count > 1)
{
iActivePopup = new PopupMultiCellSelection();
iActivePopup.VisibilityDelay = 0;
}
//
iActivePopup.PopupShowAsync(aScreenCoordinates, aCells, aStats, aOffsetBy, aKeyHandler);
}
public override void PrepareContent(HeapCellArrayWithStatistics aCells, HeapStatistics aStats)
{
try
{
HeapCell cell = aCells[0];
System.Diagnostics.Debug.Assert(cell.Type == HeapCell.TType.EFree);
//
StringBuilder msg = new StringBuilder();
//
msg.AppendFormat("This free cell has a {0} byte header and a is occupying a total of {1} byte(s) of heap space.", cell.HeaderSize, cell.Length);
msg.Append(System.Environment.NewLine + System.Environment.NewLine);
//
msg.AppendFormat("In total, this heap contains {0} bytes of free space.", aStats.StatsFree.TypeSize);
msg.Append(System.Environment.NewLine + System.Environment.NewLine);
//
if (cell.Symbol != null)
{
// Free cells can contain symbols if we attempt to decode them...
msg.AppendFormat("The free cell may have originally been of type \"{0}.\"", cell.SymbolString);
msg.Append(System.Environment.NewLine + System.Environment.NewLine);
}
//
iLbl_Description.Text = msg.ToString();
}
finally
{
base.PrepareContent(aCells, aStats);
}
}
internal override void Track(HeapCell aCell)
{
if (aCell.Symbol != null && aCell.Symbol.IsDefault)
{
System.Diagnostics.Debug.WriteLine("Unknown cell: " + aCell.ToStringExtended() + ", size: " + aCell.Symbol.Size + ", " + aCell.Symbol.Object);
}
if (aCell.Type == HeapCell.TType.EAllocated && !aCell.IsUnknown)
{
System.Diagnostics.Debug.Assert(aCell.Symbol != null);
base.HandleCell(aCell);
uint address = (uint)aCell.Symbol.Address;
TrackingInfo entry = iList[address];
// If we found an entry, then associate this cell with it.
// Otherwise, we'll need to make a new entry...
if (entry == null)
{
entry = new TrackingInfo(aCell.Symbol);
entry.PayloadLength = aCell.PayloadLength;
iList.Add(address, entry);
}
entry.Associate(aCell);
}
}
private string CreateCellContentsQuickView(HeapCell aCell)
{
const int KDWordsPerLine = 4;
StringBuilder ret = new StringBuilder();
//
ret.Append("<table>");
int rawItemsCount = Math.Min(KDWordsPerLine * 2, aCell.RawItems.Count);
for (int i = 0; i < rawItemsCount; i += KDWordsPerLine)
{
ret.Append("<tr>");
// Work out how many items on this line
int runIndex;
int runExtent = i + KDWordsPerLine;
RawItem rawItem = null;
// First set of columns - original data
for (runIndex = i; runIndex < runExtent; runIndex++)
{
// Get the item
if (runIndex < rawItemsCount)
{
rawItem = aCell[runIndex];
ret.Append("<td align=center>" + rawItem.OriginalData.ToString("x8") + "</td>");
}
else
{
ret.Append("<td></td>");
rawItem = null;
}
}
ret.Append("<td> </td>");
// Second set of columns - characterised data
for (runIndex = i; runIndex < runExtent; runIndex++)
{
// Get the item
if (runIndex < rawItemsCount)
{
rawItem = aCell[runIndex];
ret.Append("<td align=center>" + HTMLEntityUtility.Entitize(rawItem.OriginalCharacterisedData) + "</td>");
}
else
{
ret.Append("<td></td>");
rawItem = null;
}
}
ret.Append("</tr>");
}
ret.Append("</table>");
//
return(ret.ToString());
}
private void DoWriteHeapToFile(StreamWriter aWriter)
{
aWriter.WriteLine("Cell\t\tCounter\t\tLength\t\tSymbol");
aWriter.WriteLine("");
//
HeapCellArray heapItems = iReconstructor.Data;
for (int r = 0; r < heapItems.Count; r++)
{
HeapCell entry = (HeapCell)heapItems[r];
//
if (iShowOnlySymbolicMatches == false || (iShowOnlySymbolicMatches == true && entry.Symbol != null))
{
StringBuilder line = new StringBuilder();
//
line.Append(entry.Address.ToString("x8"));
line.Append("\t");
line.Append(entry.AllocationNumber.ToString("d8"));
line.Append("\t");
line.Append(entry.Length.ToString("x8"));
line.Append("\t");
if (entry.Symbol != null)
{
line.Append(entry.Symbol.Name);
}
//
aWriter.WriteLine(line.ToString());
}
}
}
private const int KMinimumUtilisationPercentage = 10; // Percent
#endregion
#region Internal methods
private static int AsPercentage(HeapCell aCell, int aLength)
{
uint totalLength = aCell.PayloadLength;
float ret = ((float)aLength / (float)totalLength) * 100.0f;
return((int)ret);
}
private static TreeNode CreateChildNode(HeapCell aParent, HeapCell aCell, RelationshipInfo aRelationshipDescriptor /* optional */)
{
StringBuilder caption = new StringBuilder();
caption.Append("[" + aCell.Address.ToString("x8") + "] ");
if (aRelationshipDescriptor != null)
{
caption.Append("[" + aRelationshipDescriptor.LinkAddressOffsetWithinFromCell.ToString("d4") + "] ");
}
caption.Append("[" + aCell.PayloadLength.ToString("d6") + "] ");
//
System.Drawing.Color foreColour = Color.Black;
if (aCell.Symbol != null)
{
caption.Append(aCell.Symbol.NameWithoutVTablePrefix);
foreColour = Color.Blue;
}
else
{
caption.Append("No symbol");
foreColour = Color.LightGray;
}
//
TreeNode node = new TreeNode(caption.ToString());
node.ForeColor = foreColour;
return(node);
}
private void UpdateSizingTextBoxByType(TSizingType aType)
{
string size = string.Empty;
//
TreeNode node = iTreeView.SelectedNode;
if (node != null && node.Tag != null && node.Tag is HeapCell)
{
HeapCell selectedCell = (HeapCell)node.Tag;
//
switch (aType)
{
case TSizingType.ESizingTypePayloadSize:
size = selectedCell.PayloadLength.ToString("d12");
break;
case TSizingType.ESizingTypePayloadSizeIncludingChildren:
size = selectedCell.PayloadLengthIncludingLinkedCells.ToString("d12");
break;
case TSizingType.ESizingTypePayloadSizeJustChildren:
size = (selectedCell.PayloadLengthIncludingLinkedCells - selectedCell.PayloadLength).ToString("d12");
break;
case TSizingType.ESizingTypePayloadSizeRecursive:
size = selectedCell.CombinedLinkedCellPayloadLengths.ToString("d12");
break;
default:
break;
}
}
//
iTextBox_CombinedSize.Text = size;
}
public override void PrepareContent(HeapCellArrayWithStatistics aCells, HeapStatistics aStats)
{
try
{
HeapCell cell = aCells[0];
System.Diagnostics.Debug.Assert(cell.Type == HeapCell.TType.EAllocated);
System.Diagnostics.Debug.Assert(cell.Symbol != null);
RelationshipManager relMgr = cell.RelationshipManager;
//
TrackingInfo info = aStats.StatsAllocated.TrackerSymbols[cell.Symbol];
int instCount = info.AssociatedCellCount;
//
Title = instCount + " Instance(s)";
//
StringBuilder msg = new StringBuilder();
//
msg.AppendFormat("This allocated cell is an instance of {0} from {1}", cell.Symbol.NameWithoutVTablePrefix, cell.Symbol.ObjectWithoutSection);
msg.Append(System.Environment.NewLine + System.Environment.NewLine);
msg.AppendFormat("There {0} {1} instance{2} of this symbol, with each instance using {3} bytes of memory (plus cell header overhead).", (instCount == 0 || instCount > 1) ? "are" : "is", info.AssociatedCellCount, (instCount == 0 || instCount > 1) ? "s" : string.Empty, cell.PayloadLength);
msg.Append(System.Environment.NewLine + System.Environment.NewLine);
//
msg.AppendFormat("In total, cells of this type use {0} bytes of heap memory", info.AssociatedMemory);
msg.Append(System.Environment.NewLine + System.Environment.NewLine);
//
msg.AppendFormat("This cell references {0} other cell(s), and is referenced by {1} cell(s)", relMgr.EmbeddedReferencesTo.Count, relMgr.ReferencedBy.Count);
msg.Append(System.Environment.NewLine + System.Environment.NewLine);
//
iLbl_Description.Text = msg.ToString();
}
finally
{
base.PrepareContent(aCells, aStats);
}
}
/// <summary>
/// adds heapcell to the heap using the given sort-value
/// </summary>
/// <param name="cell">heapcell to be used</param>
private void add(HeapCell <T> cell)
{
size++;
if ((size * 2 + 1) >= _length)
{
grow(size);
}
_data[size] = cell;
int i = size;
//do any needed swapping
while (i != 1)
{
//compare cells
if (_data[i].value <= _data[i / 2].value)
{
//if i is less than i/2, swap
HeapCell <T> temp = _data[i / 2];
_data[i / 2] = _data[i];
_data[i] = temp;
i = i / 2;
}
else //otherwise break
{
break;
}
}
}
private void DoFinaliseCell(object aCell)
{
HeapCell cell = (HeapCell)aCell;
// Do symbolic lookups
Debug(" {0x" + iState.CurrentAddress.ToString("x8") + "} - vTable: " + cell.PossibleVTableAddress.ToString("x8"));
cell.Symbol = FindMatchingSymbolVTable(cell.PossibleVTableAddress, cell.Length);
// If the MemSpy data includes stack-based function addresses stored instead
// of nesting level, then we can also try to find a matching symbol.
if (SourceData.MetaData.Heap.IsDebugAllocatorWithStoredStackAddresses)
{
cell.Symbol2 = FindMatchingSymbolAny(cell.NestingLevel);
cell.Symbol3 = FindMatchingSymbolAny(cell.AllocationNumber);
}
// Cell is now finished.
cell.ConstructionComplete(iStatistics);
// Update stats - do this after finalising the cell
// as the act of finalisation may result in the
// cell being tagged as a descriptor. This must be done
// prior to the stats update, or else we won't treat
// any cell as a descriptor!
lock ( iStatistics )
{
iStatistics.HandleCell(cell);
}
}
protected override void OnRowComplete(HeapCell aCell, int aRow, int aNextFreeColumn)
{
if (iReconstructor.SourceData.MetaData.Heap.IsDebugAllocatorWithStoredStackAddresses)
{
if (aCell.IsUnknown && aCell.Type == HeapCell.TType.EAllocated)
{
object[ , ] items = new object[1, 2];
if (aCell.Symbol2 != null)
{
items[0, 0] = aCell.Symbol2.Name;
}
else
{
items[0, 0] = string.Empty;
}
if (aCell.Symbol3 != null)
{
items[0, 1] = aCell.Symbol3.Name;
}
else
{
items[0, 1] = string.Empty;
}
Range range = Utils.GetRangeByColumnAndRow(aRow, 5, aRow, 6, Worksheet);
range.Value2 = items;
}
}
}
public void PopupShowAsync(Point aLocation, HeapCell aCell, RawItem aItem, HeapStatistics aStats, Size aOffset, System.Windows.Forms.KeyEventHandler aKeyHandler)
{
//System.Diagnostics.Debug.WriteLine( "PopupBase - Timer Started" );
iKeyHandler = aKeyHandler;
HeapCellArrayWithStatistics array = new HeapCellArrayWithStatistics();
array.Add(aCell);
PrepareContent(array, aStats, aItem);
//
iHoverPos = aLocation;
//
iShowPos = aLocation;
iShowPos.Offset(aOffset.Width, aOffset.Height);
// If we are using an async timer delay then we must start the timer and
// when it expires, the popup will become visible. Otherwise, we show
// the popup immediately.
if (VisibilityDelay > 0)
{
iTimer.Stop();
iTimer.Enabled = true;
iTimer.Start();
}
else
{
PopupShow();
}
}
private Color ColourForHeapCell(HeapCell aCell)
{
Color ret = KBaselineColourDescriptor;
//
if (!aCell.IsDescriptor)
{
float rF = KRampBaselineColourStart.R;
float gF = KRampBaselineColourStart.G;
float bF = KRampBaselineColourStart.B;
//
float count = aCell.RelationshipManager.EmbeddedReferencesTo.Count + 1.0f;
float val = (float)Math.Log(count);
val /= iDomain;
//
rF += ((KRampBaselineColourEnd.R - KRampBaselineColourStart.R) * val);
gF += ((KRampBaselineColourEnd.G - KRampBaselineColourStart.G) * val);
bF += ((KRampBaselineColourEnd.B - KRampBaselineColourStart.B) * val);
//
int r = Math.Min(Math.Max(0, (int)rF), 255);
int g = Math.Min(Math.Max(0, (int)gF), 255);
int b = Math.Min(Math.Max(0, (int)bF), 255);
//
return(System.Drawing.Color.FromArgb(r, g, b));
}
//
return(ret);
}
public static DescriptorInfo DescriptorInfo(HeapCell aCell, HeapStatistics aStats)
{
DescriptorInfo ret = null;
//
if (iAlgorithms.Count == 0)
{
PrepareAlgorithms(aStats);
}
//
foreach (DescriptorAlgorithmBase alg in iAlgorithms)
{
bool isDes = alg.IsDescriptor(aCell, out ret);
if (isDes && ret != null)
{
// We won't allow any algorithm to "recognise" the heap cell as a descriptor
// unless it can say that the length is > 0.
int length = ret.Length;
if (length > 0)
{
break;
}
else
{
ret = null;
}
}
}
return(ret);
}
public void HeapCellRenderingComplete(Graphics aGraphics, HeapCell aCell, HeapCellMetaData aMetaData)
{
SelectionBorder.HeapCellRenderingComplete(aGraphics, aCell, aMetaData);
Header.HeapCellRenderingComplete(aGraphics, aCell, aMetaData);
Content.HeapCellRenderingComplete(aGraphics, aCell, aMetaData);
ContentBorder.HeapCellRenderingComplete(aGraphics, aCell, aMetaData);
}
public override void PrepareContent(HeapCellArrayWithStatistics aCells, HeapStatistics aStats, RawItem aRawItem)
{
try
{
System.Diagnostics.Debug.Assert(aCells.Count == 1);
System.Diagnostics.Debug.Assert(aRawItem.Tag != null && aRawItem.Tag is RelationshipInfo);
HeapCell cell = aCells[0];
RelationshipManager relMgr = cell.RelationshipManager;
RelationshipInfo relInfo = (RelationshipInfo)aRawItem.Tag;
//
StringBuilder msg = new StringBuilder();
//
msg.AppendFormat("This is an embedded reference to the cell at address 0x{0}", relInfo.ToCell.Address.ToString("x8"));
if (relInfo.ToCell.Symbol != null)
{
msg.AppendFormat(", which is an instance of a {0} object.", relInfo.ToCell.SymbolString);
}
msg.Append(System.Environment.NewLine + System.Environment.NewLine);
//
msg.AppendFormat("In total, this cell references {0} other cell(s), and is referenced by {1} cell(s)", relMgr.EmbeddedReferencesTo.Count, relMgr.ReferencedBy.Count);
msg.Append(System.Environment.NewLine + System.Environment.NewLine);
//
iLbl_Description.Text = msg.ToString();
}
finally
{
base.PrepareContent(aCells, aStats, aRawItem);
}
}
private void Navigator_NavNewColumn(HeapCell aCell, HeapCellMetaData aMetaData, uint aAddress, Point aPixelPos, Point aBoxPos, Size aDimensions, Size aBoxSize, Size aPadding)
{
// Draw content
iFactory.Renderers.Content.PaintContent(iGraphics, aMetaData, aCell, aAddress, aPixelPos, aBoxSize, aPadding);
// Draw cell border
iFactory.Renderers.ContentBorder.PaintContentBorder(iGraphics, aMetaData, aCell, aAddress, aPixelPos, aBoxSize, aPadding);
// If we are handling a click & drag operation, then check whether the cell
// needs a border.
if (iMouseSelectionCell != null)
{
// Get the cell index within the cell array
int index = CellIndex(aCell);
int mouseBoundLower = (int)iMouseSelectionCellBoundaryLower.Tag;
int mouseBoundUpper = (int)iMouseSelectionCellBoundaryUpper.Tag;
if (index >= mouseBoundLower && index <= mouseBoundUpper)
{
iFactory.Renderers.SelectionBorder.PaintSelectionBorder(iGraphics, aMetaData, aCell, aAddress, aPixelPos, aBoxSize, aPadding, THeapSelectionBorderType.ESelectionMouse);
}
}
else if (iFocusedCellKeyboard == aCell)
{
// Draw border around currently mouse over'd cell
iFactory.Renderers.SelectionBorder.PaintSelectionBorder(iGraphics, aMetaData, aCell, aAddress, aPixelPos, aBoxSize, aPadding, THeapSelectionBorderType.ESelectionKeyboard);
}
else if (iFocusedCellMouse == aCell)
{
// Draw border around currently mouse over'd cell
iFactory.Renderers.SelectionBorder.PaintSelectionBorder(iGraphics, aMetaData, aCell, aAddress, aPixelPos, aBoxSize, aPadding, THeapSelectionBorderType.ESelectionMouse);
}
}
internal virtual void HandleCell(HeapCell aCell)
{
++iTypeCount;
//
iTypeSizeHeader += aCell.HeaderSize;
iTypeSizePayload += aCell.PayloadLength;
//
iDistribution.Register(aCell.Length);
//
if (iCellLargest == null || aCell.Length > iCellLargest.Length)
{
iCellLargest = aCell;
}
if (iCellSmallest == null || aCell.Length < iCellSmallest.Length)
{
iCellSmallest = aCell;
}
//
if (iCellAllocationNumberLargest == null || aCell.AllocationNumber > iCellAllocationNumberLargest.AllocationNumber)
{
iCellAllocationNumberLargest = aCell;
}
if (iCellAllocationNumberSmallest == null || aCell.AllocationNumber > iCellAllocationNumberSmallest.AllocationNumber)
{
iCellAllocationNumberSmallest = aCell;
}
}
public HeapCell CellByBoxCoordinates(Point aBoxCoordinates)
{
uint address = AddressByBoxCoordinates(aBoxCoordinates);
HeapCell ret = Cells.CellByAddress(address);
return(ret);
}
public int CellIndex(HeapCell aCell)
{
int index = -1;
Cells.CellByExactAddress(aCell.Address, out index);
return(index);
}
private void iRenderer_CellDoubleClicked(HeapCell aCell)
{
if (CellDoubleClicked != null)
{
CellDoubleClicked(aCell);
}
}
public static Color ColourByCellType(HeapCell aCell, out bool aIsUnknown)
{
aIsUnknown = false;
Color ret = Color.WhiteSmoke;
//
switch (aCell.Type)
{
case HeapCell.TType.EAllocated:
{
if (aCell.IsDescriptor)
{
ret = CellAllocatedDescriptor;
}
else if (aCell.Symbol != null)
{
ret = CellAllocatedWithSymbol;
}
else
{
aIsUnknown = true;
ret = CellAllocatedUnknown;
}
break;
}
case HeapCell.TType.EFree:
ret = CellFree;
break;
}
//
return(ret);
}
public void HeapCellRenderingComplete(Graphics aGraphics, HeapCell aCell, HeapCellMetaData aMetaData)
{
Color fillColour = RampedColourByIntensityRange(KBiggestCellColour, aCell.Length, iCellLengthSmallest, iCellLengthLongest);
//
string text = aCell.SymbolStringWithoutDescriptorPrefix;
PaintBoxedTextWithLuminanceHandling(text, aGraphics, fillColour);
}
private void iRenderer_CellRightClicked(HeapCell aCell, RawItem aRawItem, Point aViewerPos)
{
if (CellRightClicked != null)
{
Point screenPos = iRenderer.PointToScreen(aViewerPos);
CellRightClicked(aCell, aRawItem, screenPos);
}
}
public void HeapCellRenderingComplete(Graphics aGraphics, HeapCell aCell, HeapCellMetaData aMetaData)
{
Color fillColour = ColourForHeapCell(aCell);
//
string text = aCell.SymbolStringWithoutDescriptorPrefix;
PaintBoxedTextWithLuminanceHandling(text, aGraphics, fillColour);
}
public override HeapCell this[int aIndex]
{
get
{
HeapCell ret = iItems[aIndex];
return(ret);
}
}
public static string HeapCellFileNameAndPath(HeapCell aCell, string aBasePath, string aStandardSubDir)
{
string basicName = HeapCellFileName(aCell);
string combinedSubDir = HeapCellDirectory(aCell, aStandardSubDir, System.IO.Path.DirectorySeparatorChar);
string heapDataFileName = HeapToHTMLConverter.PageFileNameEnsuringPathExists(basicName, aBasePath, combinedSubDir);
return(heapDataFileName);
}
