/// <summary>
/// Wire up parsing of CLR event data from the specified ETWTraceEventSource.
/// </summary>
/// <param name="eventSource">The ETWTraceEventSource from which to parse the data.</param>
private void ParseClrTraceEvents(ETWTraceEventSource eventSource)
{
if (m_clrEvents == ClrTraceEventParser.Keywords.None)
{
return;
}
var clrTraceEventParser = new ClrTraceEventParser(eventSource);
// iterate over each set bit, wiring up a callback to parse the data
ulong eventBits = (ulong)m_clrEvents;
int bitPos = 0;
while (eventBits > 0)
{
// cycle through until a set bit is found
while ((((ulong)eventBits) & (ulong)(1 << bitPos)) == 0)
{
++bitPos;
Debug.Assert(bitPos < 64);
}
var bitVal = (ulong)(1 << bitPos);
// now strip it from eventBits and covert it to its enum value
eventBits ^= bitVal;
ClrTraceEventParser.Keywords clrEvent = (ClrTraceEventParser.Keywords)bitVal;
// aggregate the high and low events if both are available (enabling both provides a more complete value)
if ((clrEvent & ClrTraceEventParser.Keywords.GCSampledObjectAllocationHigh) == ClrTraceEventParser.Keywords.GCSampledObjectAllocationHigh ||
(clrEvent & ClrTraceEventParser.Keywords.GCSampledObjectAllocationLow) == ClrTraceEventParser.Keywords.GCSampledObjectAllocationLow ||
(clrEvent & ClrTraceEventParser.Keywords.GCAllObjectAllocation) == ClrTraceEventParser.Keywords.GCAllObjectAllocation)
{
if (!m_aed.ClrEventsData.ContainsKey(ClrPerfEvents.GCBytesAllocated))
{
m_aed.AddData(new EventDataScalarLong <ClrPerfEvents>(ClrPerfEvents.GCBytesAllocated));
}
var gcBytesAllocated = (EventDataScalarLong <ClrPerfEvents>)m_aed.ClrEventsData[ClrPerfEvents.GCBytesAllocated];
clrTraceEventParser.GCSampledObjectAllocation += delegate(GCSampledObjectAllocationTraceData data)
{
if (string.Compare(data.ProcessName, m_process, true) == 0)
{
gcBytesAllocated.Value += data.TotalSizeForTypeSample;
m_processFound = true;
}
};
}
else
{
Console.WriteLine("WARNING: CLR event {0} NYI for reporting.", clrEvent);
}
}
}
static AggregateEventsData MegeData(ICollection <AggregateEventsData> eventsData)
{
if (eventsData == null)
{
throw new ArgumentNullException("eventsData");
}
// verify that the test and platform values are homogenous
string testName = null;
Platform? platform = null;
Architecture?arch = null;
foreach (var eventData in eventsData)
{
if (testName == null)
{
testName = eventData.TestName;
}
else if (string.Compare(testName, eventData.TestName, StringComparison.OrdinalIgnoreCase) != 0)
{
throw new InvalidOperationException(string.Format("Cannot merge data from different tests '{0}' and '{1}'.", testName, eventData.TestName));
}
if (platform == null)
{
platform = eventData.Platform;
}
else if (platform.Value != eventData.Platform)
{
throw new InvalidOperationException(string.Format("Cannot merge data from different architectures {0} and {1}.", platform.Value, eventData.Platform));
}
if (arch == null)
{
arch = eventData.Architecture;
}
else if (arch.Value != eventData.Architecture)
{
throw new InvalidOperationException(string.Format("Cannot merge data from different architectures {0} and {1}.", arch.Value, eventData.Architecture));
}
}
AggregateEventsData mergedEventsData = new AggregateEventsData(testName, platform.Value, arch.Value);
var clrEvents = new List <BaseEventData <ClrPerfEvents> >(eventsData.Count);
var kernelEvents = new List <BaseEventData <KernelPerfEvents> >(eventsData.Count);
foreach (var eventData in eventsData)
{
foreach (var clrEventData in eventData.ClrEventsData.Values)
{
clrEvents.Add(clrEventData);
}
foreach (var kernelEventData in eventData.KernelEventsData.Values)
{
kernelEvents.Add(kernelEventData);
}
}
mergedEventsData.AddData(clrEvents[0].MergeEventData(clrEvents));
mergedEventsData.AddData(kernelEvents[0].MergeEventData(kernelEvents));
return(mergedEventsData);
}
