public static OutputStat operator +(OutputStat o1, OutputStat o2)
{
if (o1 == EmptyStat && o2 == EmptyStat)
return EmptyStat;
OutputStat o_result = new OutputStat ();
o_result.stat_count = o1.stat_count + o2.stat_count;
Utils.AssertEqual<string> (o1.stat_name, o2.stat_name);
o_result.stat_name = o1.stat_name;
Utils.AssertEqual<int> ((int)o1.cumulation_type, (int)o2.cumulation_type);
o_result.cumulation_type = o1.cumulation_type;
switch (o_result.cumulation_type) {
case CumulationType.MIN_MAX_AVG:
o_result.min_val = Math.Min (o1.min_val, o2.min_val);
o_result.max_val = Math.Max (o1.max_val, o2.max_val);
o_result.stat_value = o1.stat_value + o2.stat_value;
break;
case CumulationType.SUM:
case CumulationType.AVERAGE:
o_result.stat_value = o1.stat_value + o2.stat_value;
break;
}
return o_result;
}
public OutputStatSet GetStats()
{
OutputStatSet nurseryStat = null;
OutputStatSet majorStat = null;
OutputStatSet resultStat = new OutputStatSet ();
IEnumerable<GCCollection> majorList;
if (majorSyncCollections.Count > 0) {
majorList = majorSyncCollections;
Utils.Assert (majorConcCollections.Count == 0);
} else if (majorConcCollections.Count > 0) {
majorList = majorConcCollections;
Utils.Assert (majorSyncCollections.Count == 0);
} else {
majorList = new List<GCCollection> ();
}
resultStat |= new OutputStat ("Time (s)", Time, CumulationType.AVERAGE);
resultStat |= new OutputStat ("Num Minor", nurseryCollections.Count, CumulationType.AVERAGE);
resultStat |= new OutputStat ("Num Major", majorList.Count<GCCollection> (), CumulationType.AVERAGE);
resultStat |= new OutputStat ("Avg Mem Usage (MB)", ComputeMemoryUsage (), CumulationType.AVERAGE);
resultStat |= OutputStat.EmptyStat;
foreach (NurseryCollection nurseryCollection in nurseryCollections)
nurseryStat += nurseryCollection.GetStats ();
if (nurseryStat != null)
nurseryStat.Normalize ();
resultStat |= nurseryStat;
resultStat |= OutputStat.EmptyStat;
foreach (GCCollection majorCollection in majorList)
majorStat += majorCollection.GetStats ();
if (majorStat != null)
majorStat.Normalize ();
resultStat |= majorStat;
return resultStat;
}
public virtual OutputStatSet GetStats()
{
OutputStatSet stats = new OutputStatSet ();
stats |= new OutputStat (string.Format ("{0} Custom Range (ms)", major ? "Major" : "Minor"), (custom_event_end - custom_event_start) * 1000, CumulationType.MIN_MAX_AVG, true);
return stats;
}
public override OutputStatSet GetStats()
{
OutputStatSet stats = new OutputStatSet ();
stats |= new OutputStat ("Total Major Pause (ms)", (end_timestamp - start_timestamp) * 1000, CumulationType.SUM);
stats |= new OutputStat ("Evacuated block sizes", evacuated_block_sizes, CumulationType.MIN_MAX_AVG);
stats ^= new OutputStat ("Major Pause (ms)", (end_timestamp - start_timestamp) * 1000, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Major Finish GS (ms)", (finish_gray_stack_end - finish_gray_stack_start) * 1000, CumulationType.MIN_MAX_AVG);
if (concurrent_sweep_end > end_timestamp) {
if (next_nursery_start != default(double) && concurrent_sweep_end > next_nursery_start) {
Utils.Assert (next_nursery_start > end_timestamp);
stats |= new OutputStat ("Concurrent Sweep (ms)", (next_nursery_start - end_timestamp) * 1000, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Forced finish Sweep (ms)", (concurrent_sweep_end - next_nursery_start) * 1000, CumulationType.MIN_MAX_AVG);
} else {
stats |= new OutputStat ("Concurrent Sweep (ms)", (concurrent_sweep_end - end_timestamp) * 1000, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Forced finish Sweep (ms)", 0, CumulationType.MIN_MAX_AVG);
}
} else {
stats |= new OutputStat ("Concurrent Sweep (ms)", 0, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Forced finish Sweep (ms)", 0, CumulationType.MIN_MAX_AVG);
}
return stats | base.GetStats ();
}
} // NT_InputStat
private static void NT_OutputStat(out Stat s)
{
Expr e = null;
String str = null;
SrcPos sp = null;
System.Collections.ArrayList values =
new System.Collections.ArrayList();
s = null;
for (;;)
{
switch (Syn.Interpret())
{
case 0:
return;
case 1: // SEM
sp = new SrcPos();
break;
case 2:
NT_Expr(out e);
break;
case 3: // SEM
values.Add(e);
break;
case 4:
Lex.GETstringAttr(out str);
break;
case 5: // SEM
values.Add(str);
break;
case 6: // SEM
values.Add("\n");
break;
case 7:
NT_Expr(out e);
break;
case 8: // SEM
values.Add(e);
break;
case 9:
Lex.GETstringAttr(out str);
break;
case 10: // SEM
values.Add(str);
break;
case 11: // SEM
values.Add("\n");
break;
case 12: // SEM
s = new OutputStat(sp, values);
break;
} // switch
} // for
} // NT_OutputStat
} // DumpSymTab
// === generate source text from symbol table and AST ===
public static void WriteStat(Stat stat)
{
switch (stat.kind)
{
case Stat.Kind.emptyStatKind:
genMcpp.WriteLine(Indent() + ";");
break;
case Stat.Kind.blockStatKind:
BlockStat b_s = (BlockStat)stat;
genMcpp.WriteLine(Indent() + "{");
IncIndent();
WriteStatList(b_s.statList);
DecIndent();
genMcpp.WriteLine(Indent() + "}");
break;
case Stat.Kind.incStatKind:
IncStat i_s = (IncStat)stat;
genMcpp.WriteLine(Indent() + i_s.vo.sy + "++;");
break;
case Stat.Kind.decStatKind:
DecStat d_s = (DecStat)stat;
genMcpp.WriteLine(Indent() + d_s.vo.sy + "--;");
break;
case Stat.Kind.assignStatKind:
AssignStat a_s = (AssignStat)stat;
genMcpp.WriteLine(Indent() + a_s.lhs + " = " + a_s.rhs + ";");
break;
case Stat.Kind.callStatKind:
CallStat c_s = (CallStat)stat;
genMcpp.WriteLine(Indent() + c_s.func + "(" + c_s.apl + ");");
break;
case Stat.Kind.ifStatKind:
IfStat if_s = (IfStat)stat;
genMcpp.WriteLine(Indent() + "if (" + if_s.cond + ")");
IncIndent();
WriteStatList(if_s.thenStat);
DecIndent();
if (if_s.elseStat != null)
{
genMcpp.WriteLine(Indent() + "else ");
IncIndent();
WriteStatList(if_s.elseStat);
DecIndent();
} // if
break;
case Stat.Kind.whileStatKind:
WhileStat w_s = (WhileStat)stat;
genMcpp.WriteLine(Indent() + "while (" + w_s.cond + ")");
IncIndent();
WriteStatList(w_s.body);
DecIndent();
break;
case Stat.Kind.breakStatKind:
genMcpp.WriteLine(Indent() + "break;");
break;
case Stat.Kind.inputStatKind:
InputStat in_s = (InputStat)stat;
genMcpp.WriteLine(Indent() + "cin >> " + in_s.vo.sy + ";");
break;
case Stat.Kind.outputStatKind:
OutputStat out_s = (OutputStat)stat;
genMcpp.Write(Indent() + "cout");
foreach (Object o in out_s.values)
{
genMcpp.Write(" << ");
if (o is Expr)
{
genMcpp.Write(o);
}
else if (o is String)
{
String s = o as String;
if (s == "\n")
{
genMcpp.Write("endl");
}
else
{
genMcpp.Write('"' + s + '"');
}
}
else
{
throw new Exception("invalid value");
}
} // foreach
genMcpp.WriteLine(";");
break;
case Stat.Kind.deleteStatKind:
DeleteStat del_s = (DeleteStat)stat;
genMcpp.WriteLine(Indent() + "delete[] " +
NameList.NameOf(del_s.vo.sy.spix) + ";");
break;
case Stat.Kind.returnStatKind:
ReturnStat r_s = (ReturnStat)stat;
genMcpp.Write(Indent() + "return");
if (r_s.e != null)
{
genMcpp.Write(" " + r_s.e);
}
genMcpp.WriteLine(";");
break;
default:
throw new Exception("invalid statement kind");
} // switch
} // WriteStatList
public override OutputStatSet GetStats()
{
OutputStatSet stats = new OutputStatSet ();
stats |= new OutputStat ("Total Major Pause (ms)", (end_timestamp - start_of_end_timestamp + end_of_start_timestamp - start_timestamp) * 1000, CumulationType.SUM);
stats |= new OutputStat ("Evacuated block sizes", evacuated_block_sizes, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Start Pause (ms)", (end_of_start_timestamp - start_timestamp) * 1000, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Minor while Conc", num_minor, CumulationType.MIN_MAX_AVG);
if (pre_major_mod_union_scan_start != default(double)) {
stats |= new OutputStat ("Conc M&S (ms)", (pre_major_mod_union_scan_start - end_of_start_timestamp) * 1000, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Major Mod Preclean (ms)", (pre_major_mod_union_scan_end - pre_major_mod_union_scan_start) * 1000, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("LOS Mod Preclean (ms)", (pre_los_mod_union_scan_end - pre_los_mod_union_scan_start) * 1000, CumulationType.MIN_MAX_AVG);
if (worker_finish_forced != default(double))
stats |= new OutputStat ("Finish conc M&S (ms)", (worker_finish_forced - pre_los_mod_union_scan_end) * 1000, CumulationType.MIN_MAX_AVG);
else
stats |= new OutputStat ("Finish conc M&S (ms)", (worker_finish - pre_los_mod_union_scan_end) * 1000, CumulationType.MIN_MAX_AVG);
} else {
if (worker_finish_forced != default(double))
stats |= new OutputStat ("Conc M&S (ms)", (worker_finish_forced - end_of_start_timestamp) * 1000, CumulationType.MIN_MAX_AVG);
else
stats |= new OutputStat ("Conc M&S (ms)", (worker_finish - end_of_start_timestamp) * 1000, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Major Mod Preclean (ms)", 0, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("LOS Mod Preclean (ms)", 0, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Finish conc M&S (ms)", 0, CumulationType.MIN_MAX_AVG);
}
stats ^= new OutputStat ("Major Pause (ms)", (end_timestamp - start_of_end_timestamp) * 1000, CumulationType.MIN_MAX_AVG);
if (worker_finish_forced != default(double))
stats |= new OutputStat ("Forced finish (ms)", (worker_finish - start_of_end_timestamp) * 1000, CumulationType.MIN_MAX_AVG);
else
stats |= new OutputStat ("Forced finish (ms)", 0, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Mod Union Major Scan (ms)", (major_mod_union_scan_end - major_mod_union_scan_start) * 1000, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Mod Union LOS Scan (ms)", (los_mod_union_scan_end - los_mod_union_scan_start) * 1000, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Major Finish GS (ms)", (finish_gray_stack_end - finish_gray_stack_start) * 1000, CumulationType.MIN_MAX_AVG);
if (concurrent_sweep_end > end_timestamp) {
if (next_nursery_start != default(double) && concurrent_sweep_end > next_nursery_start) {
Utils.Assert (next_nursery_start > end_timestamp);
stats |= new OutputStat ("Concurrent Sweep (ms)", (next_nursery_start - end_timestamp) * 1000, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Forced finish Sweep (ms)", (concurrent_sweep_end - next_nursery_start) * 1000, CumulationType.MIN_MAX_AVG);
} else {
stats |= new OutputStat ("Concurrent Sweep (ms)", (concurrent_sweep_end - end_timestamp) * 1000, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Forced finish Sweep (ms)", 0, CumulationType.MIN_MAX_AVG);
}
} else {
stats |= new OutputStat ("Concurrent Sweep (ms)", 0, CumulationType.MIN_MAX_AVG);
stats |= new OutputStat ("Forced finish Sweep (ms)", 0, CumulationType.MIN_MAX_AVG);
}
return stats | base.GetStats ();
}
