/// <summary>
/// Write one line of type statistics metric. This method adds extra columns for CSV output to see which process, cmd line and time
/// the data was generated to make it possible to record data in append mode.
/// </summary>
/// <param name="allocated">Allocated bytes</param>
/// <param name="instances">Allocates Intances</param>
/// <param name="type">Type name</param>
void WriteTypeStatisticsLine(long allocated, long instances, string type)
{
// Default format string for console output.
// fmt is ignored for CSV output where all columns are simply \t separated.
string fmt = "{0,-17:N0}\t{1,-17:N0}\t{2}";
if (IsFirstLine)
{
string[] header = new string[] { AllocatedColumnBase + DisplayUnit, InstancesColumn, TypeColumn };
if (OutputStringWriter.CsvOutput)
{
header = header.Concat(new string[] { ProcessIdColumn, TimeColumn, CommandeLineColumn, AgeColumn, NameColumn, ContextColumn }).ToArray();
}
// write header
OutputStringWriter.FormatAndWriteHeader(fmt, header);
IsFirstLine = false;
}
if (OutputStringWriter.CsvOutput)
{
OutputStringWriter.FormatAndWrite(fmt, allocated, instances, type, TargetInfo.IsLiveProcess ? TargetInfo.Pid1.ToString() : "", TimeAndOrDate, CmdLine, TargetInfo.ProcessAgeInSeconds, TargetInfo.ProcessName, Context);
}
else
{
OutputStringWriter.FormatAndWrite(fmt, allocated, instances == 0 ? "" : (object)instances, type);
}
}
/// <summary>
/// Print type statistics diff.
/// </summary>
/// <param name="typeInfos"></param>
/// <param name="typeInfos2"></param>
/// <param name="vmmap"></param>
/// <param name="vmmap2"></param>
/// <param name="topN"></param>
/// <param name="orderBySize"></param>
/// <param name="minCount"></param>
/// <returns>Allocated memory diff in KB. If VMmap data is present the total allocated memory diff for allocated managed heap, heap, private, file mappings and sharable memory is returned.</returns>
private int PrintTypeStatisticsDiff(List <TypeInfo> typeInfos, List <TypeInfo> typeInfos2, VMMapData vmmap, VMMapData vmmap2, int topN, int minCount, bool orderBySize)
{
int allocatedMemoryInKB = 0;
TypeDiffStatistics delta = GetDiffStatistics(typeInfos, typeInfos2, orderBySize);
if (minCount > 0)
{
delta.TypeDiffs = delta.TypeDiffs.Where(x => Math.Abs(orderBySize ? x.InstanceCountDiff : x.AllocatedBytesDiff) > minCount).ToList();
}
string fmt = "{0,-12:N0}\t{1,-17:N0}\t{2,-11:N0}\t{3,-11:N0}\t{4,-17:N0}\t{5,-18:N0}" +
"\t{6,-14}\t{7,-15}\t{8}";
OutputStringWriter.FormatAndWriteHeader(fmt, $"Delta({DisplayUnit})", "Delta(Instances)", "Instances", "Instances2", $"Allocated({DisplayUnit})", $"Allocated2({DisplayUnit})",
"AvgSize(Bytes)", "AvgSize2(Bytes)", "Type");
long unitDivisor = (long)DisplayUnit;
if (topN > 0)
{
foreach (var diff in delta.TypeDiffs.Take(topN))
{
if (diff.Name == FreeTypeName)
{
continue;
}
OutputStringWriter.FormatAndWrite(fmt, diff.AllocatedBytesDiff / unitDivisor, diff.InstanceCountDiff, diff?.Info.SafeCount(), diff?.Info2.SafeCount(), diff?.Info.TotalSize() / unitDivisor,
diff?.Info2.TotalSize() / unitDivisor, diff?.Info?.AverageSizePerInstance, diff?.Info2?.AverageSizePerInstance, diff.Name);
}
}
allocatedMemoryInKB = (int)(delta.DeltaBytes / (long)DisplayUnit.KB);
OutputStringWriter.FormatAndWrite(fmt, delta.DeltaBytes / unitDivisor, delta.DeltaInstances, delta.Count, delta.Count2, delta.SizeInBytes / unitDivisor,
delta.SizeInBytes2 / unitDivisor, "", "", ManagedHeapAllocated);
long heap1Size = Heap.GetTotalHeapSize();
long heap2Size = Heap2.GetTotalHeapSize();
OutputStringWriter.FormatAndWrite(fmt, (heap2Size - heap1Size) / unitDivisor, 0, 0, 0, heap1Size / unitDivisor, heap2Size / unitDivisor, "", "", ManagedHeapSize);
if (vmmap != null && vmmap2 != null && vmmap.HasValues && vmmap2.HasValues)
{
var diff = vmmap2 - vmmap;
WriteVMMapDataDiff(GetSimpleDiffFormatter(fmt, DisplayUnit), vmmap, vmmap2, diff);
OutputStringWriter.FormatAndWrite(fmt, (diff.AllocatedBytesWithoutManagedHeap + delta.DeltaBytes) / unitDivisor, "", "", "",
(delta.SizeInBytes + vmmap.AllocatedBytesWithoutManagedHeap) / unitDivisor, (vmmap2.AllocatedBytesWithoutManagedHeap + delta.SizeInBytes2) / unitDivisor, ""
, "", AllocatedTotal);
// When VMMap data is present add the other memory types which usually leak as well also to the allocation number.
allocatedMemoryInKB += (int)(diff.AllocatedBytesWithoutManagedHeap / (long)DisplayUnit.KB);
}
return(allocatedMemoryInKB);
}
