예제 #1
0
        private void PrintRunSummary(ThreadedRunResult runResult)
        {
            var sb = new StringBuilder();

            sb.Append(runResult.TestName);
            if (runResult.Successful)
            {
                sb.AppendLine(" (Success) ");
                sb.Append(runResult.RequestsPerSecond);
                sb.Append(" RPS total (");
                var samplePoints = runResult.IterationCounters.Count;
                Debug.Assert(samplePoints > 0);
                sb.Append(samplePoints.ToString(CultureInfo.InvariantCulture));
                if (samplePoints > 1)
                {
                    sb.AppendLine(" samples)");
                    foreach (var i in new[] { 0.95, 0.99, 0.999 })
                    {
                        var percentile       = (i * 100).ToString(CultureInfo.InvariantCulture);
                        var resultPercentile = GetPercentile(runResult, i, c => ((ThreadedIterationCounter)c).RequestsPerSecond, false);
                        var resultName       = string.Format("{0} - {1}th percentile", runResult.TestName, percentile);

                        sb.Append(resultPercentile);
                        sb.Append(" RPS ");
                        sb.Append(percentile);
                        sb.AppendLine("th percentile");
                    }
                }
                else
                {
                    sb.AppendLine(" iteration)");
                }
            }
            else
            {
                sb.Append(" (Fail) ");
                sb.Append(runResult.ReportedException.Message);
            }
            sb.AppendLine();
            Console.WriteLine(sb.ToString());
        }
예제 #2
0
        protected ThreadedRunResult Run(ThreadedTestDefinition test)
        {
            //localize test settings
            var threadCount = 8;

            if (test.ThreadCount.HasValue)
            {
                threadCount = test.ThreadCount.Value;
            }
            var warmupDuration = 10000;

            if (test.WarmupDuration.HasValue)
            {
                warmupDuration = test.WarmupDuration.Value;
            }
            var testDuration = 60000;

            if (test.TestDuration.HasValue)
            {
                testDuration = test.TestDuration.Value;
            }
            var testName = test.TestName ?? test.GetType() + "#" + test.GetHashCode();

            var setup              = test.Setup;
            var run                = test.Run;
            var cleanup            = test.Cleanup;
            var threadStateFactory = test.ThreadStateFactory;

            //validate
            if (run == null)
            {
                throw new ArgumentNullException(string.Format("Verify that test {0} has a run action.", testName));
            }

            //setup
            try
            {
                if (setup != null)
                {
                    setup();
                }
            }
            catch (Exception e)
            {
                return(new ThreadedRunResult(testName, e));
            }

            var iterationSnaps = new List <Tuple <long, long> >();

            var iterationCounter = 0L;
            var testStopSignal   = false;

            Action decoratedRunAction = () =>
            {
                var state = threadStateFactory();
                do
                {
                    run(state);
                    Interlocked.Increment(ref iterationCounter);
                }while (!testStopSignal);
            };

            Action rpsCounterAction = () =>
            {
                do
                {
                    var current = Interlocked.Read(ref iterationCounter);
                    iterationSnaps.Add(new Tuple <long, long>(current, GC.GetTotalMemory(false)));
                    Thread.Sleep(1000);
                }while (!testStopSignal);
            };

            var workers = new List <Thread>();

            //add worker tasks
            for (var i = 0; i < threadCount; ++i)
            {
                workers.Add(new Thread(new ThreadStart(decoratedRunAction)));
            }

            long totalExecutionTime;

            //run
            try
            {
                var runStopWatch = new Stopwatch();
                runStopWatch.Start();
                foreach (var worker in workers)
                {
                    worker.Start();
                }
                // warmup
                runStopWatch.Restart();
                do
                {
                    Thread.Sleep(1000);
                }while (runStopWatch.ElapsedMilliseconds < warmupDuration);
                //add rps counter thread
                Thread counter = null;
                workers.Add(counter = new Thread(new ThreadStart(rpsCounterAction)));
                counter.Start();
                //actual run
                runStopWatch.Restart();
                do
                {
                    Thread.Sleep(1000);
                }while (runStopWatch.ElapsedMilliseconds < testDuration);
                testStopSignal = true;
                runStopWatch.Stop();
                totalExecutionTime = runStopWatch.ElapsedMilliseconds / 1000;
            }
            catch (Exception e)
            {
                return(new ThreadedRunResult(testName, e));
            }

            //summarize iteration counters
            var prevCummulativeValue = 0L;
            var iterationCounters    = new List <ThreadedIterationCounter>();

            foreach (var snap in iterationSnaps)
            {
                if (snap.Item1 == 0)
                {
                    continue;
                }

                var iterationRps = snap.Item1 - prevCummulativeValue;
                iterationCounters.Add(new ThreadedIterationCounter
                {
                    RequestsPerSecond = iterationRps,
                    WorkingSet        = snap.Item2
                });
                prevCummulativeValue += iterationRps;
            }

            var result = new ThreadedRunResult(testName, iterationCounter / totalExecutionTime, GC.GetTotalMemory(false), iterationCounters);

            //cleanup
            try
            {
                if (cleanup != null)
                {
                    cleanup();
                }
            }
            catch (Exception e)
            {
                result.ReportedException = e;
            }

            //report
            return(result);
        }