예제 #1
0
        /// <summary>
        /// Generate the PerfEventsData from the info provided to the ctor.
        /// </summary>
        /// <returns>A new instance of the AggregateEventsData class.</returns>
        public AggregateEventsData Generate()
        {
            using (var eventSource = new ETWTraceEventSource(m_etlFile))
            {
                if (eventSource.EventsLost > 0)
                {
                    Console.WriteLine("WARNING: {0} events were lost during capture.", eventSource.EventsLost);
                }

                m_aed = new AggregateEventsData(m_testName, Platform.Windows, eventSource.PointerSize == 8 ? Architecture.Amd64 : Architecture.X86);

                ParseClrTraceEvents(eventSource);
                ParseKernelTraceEvents(eventSource);

                // process the stream of events
                eventSource.Process();
            }

            if (!m_processFound)
            {
                throw new ArgumentException(string.Format("No data was found for process named {0}.  Please ensure the name of the process is correct.", m_process));
            }

            return(m_aed);
        }
예제 #2
0
        public AggregateEventsDataComparer(AggregateEventsData baseline, AggregateEventsData live)
        {
            if (baseline == null)
            {
                throw new ArgumentNullException("baseline");
            }

            if (live == null)
            {
                throw new ArgumentNullException("live");
            }

            // ensure that the data being compared is from the same architecture, platform and test

            if (string.Compare(baseline.TestName, live.TestName, StringComparison.OrdinalIgnoreCase) != 0)
            {
                throw new ArgumentException(string.Format("Cannot compare results across different tests.  Baseline is {0} and live is {1}.", baseline.TestName, live.TestName));
            }

            // TODO: there might be cases where cross-platform comparisons make sense
            if (baseline.Platform != live.Platform)
            {
                throw new ArgumentException(string.Format("Cannot compare results across different platforms.  Baseline is {0} and live is {1}.", baseline.Platform, live.Platform));
            }

            if (baseline.Architecture != live.Architecture)
            {
                throw new ArgumentException(string.Format("Cannot compare results across different architectures.  Baseline is {0} and live is {1}.", baseline.Architecture, live.Architecture));
            }

            m_baseline = baseline;
            m_live     = live;
        }
예제 #3
0
        static int Main(string[] args)
        {
            var exitCode = 1;

            try
            {
                var cmdOptions = PowerArgs.Args.Parse <CommandLineOptions>(args);

                if (string.Compare(cmdOptions.Baseline, cmdOptions.Live, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    throw new ArgumentException("The values of baseline and live parameters cannot be identical.");
                }

                var xmls = new XmlSerializer(typeof(AggregateEventsData));

                AggregateEventsData baseline = null;
                AggregateEventsData live     = null;

                using (StreamReader reader = new StreamReader(cmdOptions.Baseline))
                {
                    baseline = (AggregateEventsData)xmls.Deserialize(reader);
                }

                using (StreamReader reader = new StreamReader(cmdOptions.Live))
                {
                    live = (AggregateEventsData)xmls.Deserialize(reader);
                }

                var dataComparer = new AggregateEventsDataComparer(baseline, live);

                if (dataComparer.CompareResults())
                {
                    Console.WriteLine("PASS: perf results are ok");
                    exitCode = 0;
                }
                else
                {
                    Console.WriteLine("FAIL: perf results out of tolerance");
                }
            }
            catch (PowerArgs.ArgException ex)
            {
                Console.WriteLine(ex.Message);
                Console.WriteLine(PowerArgs.ArgUsage.GenerateUsageFromTemplate <CommandLineOptions>());
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.WriteLine(ex.StackTrace);
            }

            return(exitCode);
        }
예제 #4
0
        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);
        }