TimingData SummarizeParsedTimingData(string SummaryName, TimingDataType TimingType, IEnumerable <string> Lines)
{
TimingData Summary = new TimingData()
{
Name = SummaryName, Type = TimingDataType.Summary
};
List <TimingData> ParsedTimingData = ParseTimingDataFromLines(TimingType, Lines);
foreach (TimingData Data in ParsedTimingData)
{
// See if we've already added a child that matches this data's name. If so, just add to the duration.
TimingData MatchedData;
if (Summary.Children.TryGetValue(Data.Name, out MatchedData))
{
MatchedData.ExclusiveDuration += Data.ExclusiveDuration;
}
else
{
Summary.AddChild(Data);
}
}
// Exclusive duration was originally set to the inclusive value, remove the children's durations to get the
// actual exclusive duration.
Summary.ExclusiveDuration = Summary.ExclusiveDuration - Summary.Children.Sum(c => c.Value.InclusiveDuration);
return(Summary);
}
TimingData SummarizeParsedTimingData(string SummaryName, TimingDataType TimingType, IEnumerable <string> Lines)
{
TimingData Summary = new TimingData()
{
Name = SummaryName, Type = TimingDataType.Summary
};
List <TimingData> ParsedTimingData = ParseTimingDataFromLines(TimingType, Lines);
foreach (TimingData Data in ParsedTimingData)
{
// See if we've already added a child that matches this data's name. If so, just add to the duration.
TimingData MatchedData;
if (Summary.Children.TryGetValue(Data.Name, out MatchedData))
{
MatchedData.Count += 1;
MatchedData.ExclusiveDuration += Data.ExclusiveDuration;
}
else
{
Summary.AddChild(Data);
}
}
return(Summary);
}
List <TimingData> ParseTimingDataFromLines(TimingDataType TimingType, IEnumerable <string> Lines)
{
List <TimingData> ParsedTimingData = new List <TimingData>();
int LastDepth = 0;
TimingData LastTimingData = null;
foreach (string Line in Lines)
{
int LineDepth;
TimingData CurrentTimingData = ParseTimingDataFromLine(TimingType, Line, out LineDepth);
if (LineDepth == 0)
{
ParsedTimingData.Add(CurrentTimingData);
}
else
{
while (LineDepth < LastDepth)
{
LastTimingData = LastTimingData.Parent;
--LastDepth;
}
// If this timing data would have a parent, add the data to that parent and reduce its exclusive
// duration by this data's inclusive duration.
TimingData ParentData = null;
if (LineDepth == LastDepth)
{
CurrentTimingData.Parent = LastTimingData.Parent;
ParentData = LastTimingData.Parent;
}
else if (LineDepth > LastDepth)
{
CurrentTimingData.Parent = LastTimingData;
ParentData = LastTimingData;
}
if (ParentData != null)
{
ParentData.AddChild(CurrentTimingData);
ParentData.ExclusiveDuration -= CurrentTimingData.InclusiveDuration;
}
}
LastTimingData = CurrentTimingData;
LastDepth = LineDepth;
}
return(ParsedTimingData);
}
public ISessionData GetDataType(TimingDataType fileType)
{
switch (fileType)
{
case TimingDataType.LapTimeData:
return(new LapData());
case TimingDataType.SpeedData:
return(new SpeedData());
case TimingDataType.GridData:
return(new GridData());
default:
return(new LapData());
}
}
public static string GetTextFileName(this TimingDataType timingDataType)
{
switch (timingDataType)
{
case TimingDataType.LapTimeData:
return("Lap Times");
case TimingDataType.SpeedData:
return("Speed Trap");
case TimingDataType.GridData:
return("Grid");
default:
return("");
}
}
TimingData ParseTimingDataFromLine(TimingDataType TimingType, string Line, out int LineDepth)
{
Match TimingDataMatch = Regex.Match(Line, TimingDataRegex);
if (!TimingDataMatch.Success)
{
LineDepth = -1;
return(null);
}
LineDepth = TimingDataMatch.Groups["Indent"].Success ? TimingDataMatch.Groups["Indent"].Value.Count() : 0;
TimingData ParsedTimingData = new TimingData()
{
Name = TimingDataMatch.Groups["Name"].Value,
Type = TimingType,
ExclusiveDuration = float.Parse(TimingDataMatch.Groups["Duration"].Value),
};
return(ParsedTimingData);
}
public static string GetPDFFileName(this TimingDataType timingDataType, Session session)
{
if (session == Session.Race)
{
return("Lap Analysis");
}
switch (timingDataType)
{
case TimingDataType.LapTimeData:
return("Lap Times");
case TimingDataType.SpeedData:
return("Speed Trap");
case TimingDataType.GridData:
return("Preliminary Classification");
default:
return("");
}
}
private IEnumerable <TimingData> GroupChildren(IEnumerable <TimingData> Children, TimingDataType Type)
{
List <TimingData> GroupedChildren = new List <TimingData>();
Dictionary <string, List <TimingData> > ChildGroups = new Dictionary <string, List <TimingData> >();
foreach (TimingData Child in Children)
{
// See if this is a templated class. If not, add it as is.
Match Match = Regex.Match(Child.Name, @"^([^<]*)(?<Template><.*>)");
if (!Match.Success)
{
GroupedChildren.Add(Child);
}
else
{
// Generate group name from template.
int TemplateParamCount = Match.Groups["Template"].Value.Count(c => c == ',') + 1;
List <string> TemplateParamSig = new List <string>(TemplateParamCount);
for (int i = 0; i < TemplateParamCount; ++i)
{
TemplateParamSig.Add("...");
}
string GroupName = Child.Name.Replace(Match.Groups["Template"].Value, String.Format("<{0}>", string.Join(", ", TemplateParamSig)));
// See if we have a group for this template already. If not, add it.
if (!ChildGroups.ContainsKey(GroupName))
{
ChildGroups.Add(GroupName, new List <TimingData>());
}
ChildGroups[GroupName].Add(Child);
}
}
// Add grouped children.
foreach (KeyValuePair <string, List <TimingData> > Group in ChildGroups)
{
if (Group.Value.Count == 1)
{
GroupedChildren.Add(Group.Value.First());
continue;
}
TimingData NewViewModel = new TimingData()
{
Name = Group.Key,
Type = Type,
};
foreach (TimingData Child in Group.Value)
{
TimingData NewChild = new TimingData()
{
Name = Child.Name, Type = Child.Type, Parent = NewViewModel, ExclusiveDuration = Child.ExclusiveDuration
};
NewViewModel.AddChild(NewChild);
}
GroupedChildren.Add(NewViewModel);
}
return(GroupedChildren);
}
public override int Execute(CommandLineArguments Arguments)
{
FileReference InputFile = Arguments.GetFileReference("-TimingFile=");
// If the tracing argument was passed, hand off to the logic to generate a JSON file compatible with
// chrome://tracing
if (Arguments.HasOption("-Tracing"))
{
ParseTimingDataToTracingFiles(InputFile);
return(0);
}
// Break the input file into the various sections for processing.
string[] AllLines = FileReference.ReadAllLines(InputFile);
List <string> Includes = new List <string>();
List <string> Classes = new List <string>();
List <string> Functions = new List <string>();
TimingDataType CurrentType = TimingDataType.None;
foreach (string Line in AllLines)
{
if (string.IsNullOrWhiteSpace(Line))
{
continue;
}
// Check for a change of type.
if (Line.StartsWith("Include Headers:", StringComparison.OrdinalIgnoreCase))
{
CurrentType = TimingDataType.Include;
continue;
}
else if (Line.StartsWith("Class Definitions:", StringComparison.OrdinalIgnoreCase))
{
CurrentType = TimingDataType.Class;
continue;
}
else if (Line.StartsWith("Function Definitions:", StringComparison.OrdinalIgnoreCase))
{
CurrentType = TimingDataType.Function;
continue;
}
// Skip the count line, we don't need it.
if (Regex.IsMatch(Line, @"^\tCount\:\s*\d*$"))
{
continue;
}
// If we didn't change types and this isn't the count line and it doesn't match the expected output,
// clear the current type and move on.
Match TimingDataMatch = Regex.Match(Line, TimingDataRegex);
if (!TimingDataMatch.Success)
{
CurrentType = TimingDataType.None;
continue;
}
// If we get to here this is a line we want to parse. Add it to the correct collection.
switch (CurrentType)
{
case TimingDataType.Include:
{
Includes.Add(Line);
break;
}
case TimingDataType.Class:
{
Classes.Add(Line);
break;
}
case TimingDataType.Function:
{
Functions.Add(Line);
break;
}
}
}
// Build the summary.
TimingData Summary = new TimingData()
{
Name = InputFile.FullName.Replace(".timing.txt", string.Empty), Type = TimingDataType.Summary
};
Summary.AddChild(SummarizeParsedTimingData("IncludeTimings", TimingDataType.Include, Includes));
Summary.AddChild(SummarizeParsedTimingData("ClassTimings", TimingDataType.Class, Classes));
Summary.AddChild(SummarizeParsedTimingData("FunctionTimings", TimingDataType.Function, Functions));
// Write out the timing binary file.
using (BinaryWriter Writer = new BinaryWriter(File.Open(InputFile.ChangeExtension(".timing.bin").FullName, FileMode.Create)))
{
Writer.Write(Summary);
}
return(0);
}
public static string GetPDFFileName(this Session session)
{
TimingDataType dataType = GetTimingDataType(session);
return(dataType.GetPDFFileName(session));
}
