public static void Main(string [] args)
{
int args_i = 0;
string outfile_name = "outfile";
if (args_i < args.Length && File.Exists (args [args_i])) {
outfile_name = args [args_i];
++args_i;
}
if (! File.Exists (outfile_name)) {
Console.WriteLine ("Can't find outfile '{0}'", outfile_name);
return;
}
string report_name = "summary";
if (args_i < args.Length && Report.Exists (args [args_i])) {
report_name = args [args_i];
++args_i;
}
Report report;
report = Report.Get (report_name);
OutfileReader reader;
reader = new OutfileReader (outfile_name);
string [] remaining_args = new string [args.Length - args_i];
for (int i = args_i; i < args.Length; ++i)
remaining_args [i - args_i] = args [i];
Console.WriteLine ();
report.Run (reader, remaining_args);
Console.WriteLine ();
}
override public void Run(OutfileReader reader, string [] args)
{
Table table;
table = new Table();
table.AddRow("SUMMARY", "");
table.AddRow("", "");
table.AddRow("Filename:", reader.Filename);
table.AddRow("Allocated Bytes:", Util.PrettySize(reader.TotalAllocatedBytes));
table.AddRow("Allocated Objects:", reader.TotalAllocatedObjects);
table.AddRow("GCs:", reader.Gcs.Length);
table.AddRow("Resizes:", reader.Resizes.Length);
table.AddRow("Final heap size:", Util.PrettySize(reader.LastResize.NewSize));
table.AddRow("", "");
table.AddRow("Distinct Types:", reader.Types.Length);
table.AddRow("Backtraces:", reader.Backtraces.Length);
table.SetAlignment(1, Alignment.Left);
Console.WriteLine(table);
}
static public void Main(string [] args)
{
int args_i = 0;
string outfile_name = "outfile";
if (args_i < args.Length && File.Exists(args [args_i]))
{
outfile_name = args [args_i];
++args_i;
}
if (!File.Exists(outfile_name))
{
Console.WriteLine("Can't find outfile '{0}'", outfile_name);
return;
}
string report_name = "summary";
if (args_i < args.Length && Report.Exists(args [args_i]))
{
report_name = args [args_i];
++args_i;
}
Report report;
report = Report.Get(report_name);
OutfileReader reader;
reader = new OutfileReader(outfile_name);
string [] remaining_args = new string [args.Length - args_i];
for (int i = args_i; i < args.Length; ++i)
{
remaining_args [i - args_i] = args [i];
}
Console.WriteLine();
report.Run(reader, remaining_args);
Console.WriteLine();
}
public override void Run(OutfileReader reader, string [] args)
{
Table table;
table = new Table ();
table.AddRow ("SUMMARY", "");
table.AddRow ("", "");
table.AddRow ("Filename:", reader.Filename);
table.AddRow ("Allocated Bytes:", Util.PrettySize (reader.TotalAllocatedBytes));
table.AddRow ("Allocated Objects:", reader.TotalAllocatedObjects);
table.AddRow ("GCs:", reader.Gcs.Length);
table.AddRow ("Resizes:", reader.Resizes.Length);
table.AddRow ("Final heap size:", Util.PrettySize (reader.LastResize.NewSize));
table.AddRow ("", "");
table.AddRow ("Distinct Types:", reader.Types.Length);
table.AddRow ("Backtraces:", reader.Backtraces.Length);
table.SetAlignment (1, Alignment.Left);
Console.WriteLine (table);
}
public override void Run(OutfileReader reader, string [] args)
{
Table table;
table = new Table ();
table.Separator = " | ";
Resize [] resizes;
resizes = reader.Resizes;
Gc [] gcs;
gcs = reader.Gcs;
int i_resize = 0;
int i_gc = 0;
long heap_size = 0;
while (i_resize < resizes.Length || i_gc < gcs.Length) {
Resize r = null;
if (i_resize < resizes.Length)
r = resizes [i_resize];
Gc gc = null;
if (i_gc < gcs.Length)
gc = gcs [i_gc];
if (i_resize != 0 || i_gc != 0)
table.AddRow ("", "", "");
string timestamp, tag, message;
if (r != null && (gc == null || r.Generation <= gc.Generation)) {
timestamp = string.Format ("{0:HH:mm:ss}", r.Timestamp);
if (r.PreviousSize == 0) {
tag = "Init";
message = String.Format ("Initialized heap to {0}",
Util.PrettySize (r.NewSize));
} else {
tag = "Resize";
message = String.Format ("Grew heap from {0} to {1}\n" +
"{2} in {3} live objects\n" +
"Heap went from {4:0.0}% to {5:0.0}% capacity",
Util.PrettySize (r.PreviousSize),
Util.PrettySize (r.NewSize),
Util.PrettySize (r.TotalLiveBytes),
r.TotalLiveObjects,
r.PreResizeCapacity, r.PostResizeCapacity);
}
heap_size = r.NewSize;
++i_resize;
} else {
timestamp = String.Format ("{0:HH:mm:ss}", gc.Timestamp);
if (gc.Generation >= 0) {
tag = "GC " + gc.Generation;
message = String.Format ("Collected {0} of {1} objects ({2:0.0}%)\n" +
"Collected {3} of {4} ({5:0.0}%)\n" +
"Heap went from {6:0.0}% to {7:0.0}% capacity",
gc.FreedObjects,
gc.PreGcLiveObjects,
gc.FreedObjectsPercentage,
Util.PrettySize (gc.FreedBytes),
Util.PrettySize (gc.PreGcLiveBytes),
gc.FreedBytesPercentage,
100.0 * gc.PreGcLiveBytes / heap_size,
100.0 * gc.PostGcLiveBytes / heap_size);
} else {
tag = "Exit";
message = String.Format ("{0} live objects using {1}",
gc.PreGcLiveObjects,
Util.PrettySize (gc.PreGcLiveBytes));
}
++i_gc;
}
table.AddRow (timestamp, tag, message);
}
table.SetAlignment (1, Alignment.Left);
table.SetAlignment (2, Alignment.Left);
Console.WriteLine (table);
}
/////////////////////////////////////////////////////////////////
public Gc(OutfileReader reader)
{
this.reader = reader;
}
public override void Run(OutfileReader reader, string [] args)
{
SortOrder order = SortOrder.ByTotalBytes;
int max_rows = 25;
string match_string = null;
bool ellipsize_names = true;
// Hacky free-form arg parser
int i = 0;
while (i < args.Length) {
string arg = args [i].ToLower ();
if (arg == "count")
order = SortOrder.ByCount;
else if (arg == "total")
order = SortOrder.ByTotalBytes;
else if (arg == "average")
order = SortOrder.ByAverageBytes;
else if (arg == "age")
order = SortOrder.ByAverageAge;
else if (arg == "backtrace" || arg == "backtraces" || arg == "bt")
order = SortOrder.ByBacktraceCount;
else if (arg == "all")
max_rows = -1;
else if (arg == "match" || arg == "matching" || arg == "like") {
++i;
match_string = args [i];
} else if (arg == "full" || arg == "long" || arg == "unellipsized")
ellipsize_names = false;
else {
int n = -1;
try {
n = Int32.Parse (arg);
} catch { }
if (n > 0)
max_rows = n;
}
++i;
}
// Generate the table
Table table;
table = new Table ();
table.AddHeaders ("Type",
"#",
"Total",
"AvSz",
"AvAge",
"BT#");
if (ellipsize_names)
table.SetStringify (0, Util.Ellipsize);
table.SetStringify (2, Util.PrettySize_Obj);
table.SetStringify (3, "0.0");
table.SetStringify (4, "0.0");
foreach (Type type in reader.Types) {
if (match_string != null && ! type.Matches (match_string))
continue;
table.AddRow (type.Name,
type.LastObjectStats.AllocatedCount,
type.LastObjectStats.AllocatedTotalBytes,
type.LastObjectStats.AllocatedAverageBytes,
type.LastObjectStats.AllocatedAverageAge,
type.BacktraceCount);
}
switch (order) {
case SortOrder.ByCount:
table.Sort (1, false);
break;
case SortOrder.ByTotalBytes:
table.Sort (2, false);
break;
case SortOrder.ByAverageBytes:
table.Sort (3, false);
break;
case SortOrder.ByAverageAge:
table.Sort (4, false);
break;
case SortOrder.ByBacktraceCount:
table.Sort (5, false);
break;
}
if (max_rows > 0)
table.MaxRows = max_rows;
Console.WriteLine (table);
if (table.RowCount > table.MaxRows) {
Console.WriteLine ();
Console.WriteLine ("(skipped {0} types)", table.RowCount - table.MaxRows);
}
}
override public void Run(OutfileReader reader, string [] args)
{
SortOrder order = SortOrder.ByTotalBytes;
int max_rows = 25;
string match_string = null;
bool ellipsize_names = true;
// Hacky free-form arg parser
int i = 0;
while (i < args.Length)
{
string arg = args [i].ToLower();
if (arg == "count")
{
order = SortOrder.ByCount;
}
else if (arg == "total")
{
order = SortOrder.ByTotalBytes;
}
else if (arg == "average")
{
order = SortOrder.ByAverageBytes;
}
else if (arg == "age")
{
order = SortOrder.ByAverageAge;
}
else if (arg == "all")
{
max_rows = -1;
}
else if (arg == "match" || arg == "matching" || arg == "like")
{
++i;
match_string = args [i];
}
else if (arg == "full" || arg == "long" || arg == "unellipsized")
{
ellipsize_names = false;
}
else
{
int n = -1;
try {
n = Int32.Parse(arg);
} catch { }
if (n > 0)
{
max_rows = n;
}
}
++i;
}
// Generate the table
Table table;
table = new Table();
table.AddHeaders("Backtrace",
"#",
"Total",
"AvSz",
"AvAge");
if (ellipsize_names)
{
table.SetStringify(0, BacktraceStringifier_Ellipsize);
}
else
{
table.SetStringify(0, BacktraceStringifier_Full);
}
table.SetStringify(2, Util.PrettySize_Obj);
table.SetStringify(3, "0.0");
table.SetStringify(4, "0.0");
foreach (Backtrace bt in reader.Backtraces)
{
if (match_string != null && !bt.Matches(match_string))
{
continue;
}
table.AddRow(bt,
bt.LastObjectStats.AllocatedCount,
bt.LastObjectStats.AllocatedTotalBytes,
bt.LastObjectStats.AllocatedAverageBytes,
bt.LastObjectStats.AllocatedAverageAge);
}
switch (order)
{
case SortOrder.ByCount:
table.Sort(1, false);
break;
case SortOrder.ByTotalBytes:
table.Sort(2, false);
break;
case SortOrder.ByAverageBytes:
table.Sort(3, false);
break;
case SortOrder.ByAverageAge:
table.Sort(4, false);
break;
}
table.SkipLines = true;
if (max_rows > 0)
{
table.MaxRows = max_rows;
}
Console.WriteLine(table);
if (table.RowCount > table.MaxRows)
{
Console.WriteLine();
Console.WriteLine("(skipped {0} backtraces)", table.RowCount - table.MaxRows);
}
}
public Backtrace(uint code, OutfileReader reader)
{
this.code = code;
this.reader = reader;
}
/////////////////////////////////////////////////////////////////
public Gc(OutfileReader reader)
{
this.reader = reader;
}
public Backtrace(uint code, OutfileReader reader)
{
this.code = code;
this.reader = reader;
}
public abstract void Run(OutfileReader reader, string [] command_line_args);
override public void Run(OutfileReader reader, string [] args)
{
Table table;
table = new Table();
table.Separator = " | ";
Resize [] resizes;
resizes = reader.Resizes;
Gc [] gcs;
gcs = reader.Gcs;
int i_resize = 0;
int i_gc = 0;
long heap_size = 0;
while (i_resize < resizes.Length || i_gc < gcs.Length)
{
Resize r = null;
if (i_resize < resizes.Length)
{
r = resizes [i_resize];
}
Gc gc = null;
if (i_gc < gcs.Length)
{
gc = gcs [i_gc];
}
if (i_resize != 0 || i_gc != 0)
{
table.AddRow("", "", "");
}
string timestamp, tag, message;
if (r != null && (gc == null || r.Generation <= gc.Generation))
{
timestamp = string.Format("{0:HH:mm:ss}", r.Timestamp);
if (r.PreviousSize == 0)
{
tag = "Init";
message = String.Format("Initialized heap to {0}",
Util.PrettySize(r.NewSize));
}
else
{
tag = "Resize";
message = String.Format("Grew heap from {0} to {1}\n" +
"{2} in {3} live objects\n" +
"Heap went from {4:0.0}% to {5:0.0}% capacity",
Util.PrettySize(r.PreviousSize),
Util.PrettySize(r.NewSize),
Util.PrettySize(r.TotalLiveBytes),
r.TotalLiveObjects,
r.PreResizeCapacity, r.PostResizeCapacity);
}
heap_size = r.NewSize;
++i_resize;
}
else
{
timestamp = String.Format("{0:HH:mm:ss}", gc.Timestamp);
if (gc.Generation >= 0)
{
tag = "GC " + gc.Generation;
message = String.Format("Collected {0} of {1} objects ({2:0.0}%)\n" +
"Collected {3} of {4} ({5:0.0}%)\n" +
"Heap went from {6:0.0}% to {7:0.0}% capacity",
gc.FreedObjects,
gc.PreGcLiveObjects,
gc.FreedObjectsPercentage,
Util.PrettySize(gc.FreedBytes),
Util.PrettySize(gc.PreGcLiveBytes),
gc.FreedBytesPercentage,
100.0 * gc.PreGcLiveBytes / heap_size,
100.0 * gc.PostGcLiveBytes / heap_size);
}
else
{
tag = "Exit";
message = String.Format("{0} live objects using {1}",
gc.PreGcLiveObjects,
Util.PrettySize(gc.PreGcLiveBytes));
}
++i_gc;
}
table.AddRow(timestamp, tag, message);
}
table.SetAlignment(1, Alignment.Left);
table.SetAlignment(2, Alignment.Left);
Console.WriteLine(table);
}
abstract public void Run(OutfileReader reader, string [] command_line_args);
