public ActionResult BenchmarkRun(string machine, string label)
        {
            BenchmarkRun run       = null;
            string       nextLabel = null; // In descending label order, so earlier...

            foreach (var candidate in repository.RunsByMachine[machine])
            {
                if (run != null)
                {
                    nextLabel = candidate.Label;
                    break;
                }
                if (candidate.Label == label)
                {
                    run = candidate;
                }
            }
            ImmutableList <SourceLogEntry> changes = null;

            if (nextLabel != null)
            {
                string earlierHash = BenchmarkRepository.HashForLabel(nextLabel);
                string thisHash    = BenchmarkRepository.HashForLabel(label);
                changes = log.EntriesBetween(earlierHash, thisHash).ToImmutableList();
            }
            return(View(new BenchmarkRunAndSourceLogs(run, changes)));
        }
示例#2
0
        public BenchmarkDiff(BenchmarkRun left, BenchmarkRun right, ImmutableList <SourceLogEntry> log)
        {
            Left  = left;
            Right = right;
            var leftResults  = left.AllResults.ToList();
            var rightResults = right.AllResults.ToList();

            LeftOnly  = leftResults.ExceptBy(rightResults, result => result.FullMethod);
            RightOnly = rightResults.ExceptBy(leftResults, result => result.FullMethod);

            var pairs = (from l in leftResults
                         join r in rightResults on l.FullMethod equals r.FullMethod
                         select new BenchmarkPair(l, r)).ToList();

            LeftBetter  = pairs.Where(pair => pair.Percent < ImprovementThreshold).ToList();
            RightBetter = pairs.Where(pair => pair.Percent > RegressionThreshold).ToList();

            bool leftEarlier = BenchmarkRepository.BuildForLabel(left.Label) < BenchmarkRepository.BuildForLabel(right.Label);

            var earlier = leftEarlier ? left : right;
            var later   = leftEarlier ? right : left;

            var earlierHash = BenchmarkRepository.HashForLabel(earlier.Label);
            var laterHash   = BenchmarkRepository.HashForLabel(later.Label);

            LogEntries = log.EntriesBetween(earlierHash, laterHash).ToList();
        }
示例#3
0
        protected Decimal?TryGetTotalByBasket(CountryBasket basket, BenchmarkRepository benchmarkRepository, String benchmarkId)
        {
            var country = basket.Country;
            var result  = this.TryGetTotalByCountry(country, benchmarkRepository, benchmarkId);

            return(result);
        }
示例#4
0
        protected Decimal?TryGetTotalByCountry(Aims.Core.Country country, BenchmarkRepository benchmarkRepository, String benchmarkId)
        {
            var benchmarkRecords = benchmarkRepository
                                   .GetBenchmarksByIsoCountryCode(country.IsoCode)
                                   .Where(x => x.BenchmarkId == benchmarkId);

            if (benchmarkRecords.Any())
            {
                Decimal?result = null;
                foreach (var record in benchmarkRecords)
                {
                    var value = record.BenchmarkWeight;
                    if (value.HasValue)
                    {
                        if (result.HasValue)
                        {
                            result = result.Value + value.Value;
                        }
                        else
                        {
                            result = value.Value;
                        }
                    }
                    else
                    {
                        // do nothing
                    }
                }
                return(result);
            }
            else
            {
                return(null);
            }
        }
示例#5
0
        protected Decimal?TryGetTotalByBasket(RegionBasket basket, BenchmarkRepository benchmarkRepository, String benchmarkId)
        {
            Decimal?result = null;

            foreach (var country in basket.Countries)
            {
                var value = TryGetTotalByCountry(country, benchmarkRepository, benchmarkId);
                if (value.HasValue)
                {
                    if (result.HasValue)
                    {
                        result = result.Value + value.Value;
                    }
                    else
                    {
                        result = value.Value;
                    }
                }
                else
                {
                    // do nothing
                }
            }
            return(result);
        }
示例#6
0
        public BenchmarksController()
        {
            string root          = HostingEnvironment.ApplicationPhysicalPath;
            string benchmarkData = Path.Combine(root, "benchmarkdata");

            repositoryWatcher = new FileWatchingReloader <BenchmarkRepository>(
                Path.Combine(benchmarkData, "index.txt"),
                () => BenchmarkRepository.Load(benchmarkData),
                ReloadTime);
            string logFile = Path.Combine(root, "hg-log.xml");

            logWatcher = new FileWatchingReloader <MercurialLog>(logFile, () => MercurialLog.Load(logFile), ReloadTime);
        }
        public static MethodHistoryModel ForMachineMethod(BenchmarkRepository repository, string machine, string method, bool allResults)
        {
            var             runs           = repository.RunsByMachine[machine];
            List <Entry>    entries        = new List <Entry>();
            BenchmarkResult previousResult = null;

            // Work things out in ascending time order, then reverse later. Too confusing otherwise!
            foreach (var run in runs.OrderBy(f => f.Start))
            {
                var result = run.AllResults.FirstOrDefault(m => m.FullMethod == method);
                if (result == null && previousResult == null)
                {
                    continue;
                }
                if (result == null)
                {
                    entries.Add(new Entry(run, "Method removed"));
                }
                else if (allResults)
                {
                    entries.Add(new Entry(run, result.NanosecondsPerCall + "ns"));
                }
                else if (previousResult == null)
                {
                    entries.Add(new Entry(run, "Method introduced"));
                }
                else
                {
                    // TODO: This only spots sudden improvements, not gradual improvements over time. Consider
                    // remembering the "last change" result and using that instead.
                    long percent = (result.PicosecondsPerCall * 100) / previousResult.PicosecondsPerCall;
                    if (percent > BenchmarkDiff.RegressionThreshold)
                    {
                        entries.Add(new Entry(run, string.Format("Regression: {0}ns to {1}ns", previousResult.NanosecondsPerCall, result.NanosecondsPerCall)));
                    }
                    if (percent < BenchmarkDiff.ImprovementThreshold)
                    {
                        entries.Add(new Entry(run, string.Format("Improvement: {0}ns to {1}ns", previousResult.NanosecondsPerCall, result.NanosecondsPerCall)));
                    }
                }
                previousResult = result;
            }
            entries.Reverse();
            return(new MethodHistoryModel {
                Machine = machine, Method = method, Entries = entries.ToImmutableList(), AllResults = allResults
            });
        }
示例#8
0
        public BenchmarkDiff(BenchmarkRun left, BenchmarkRun right, MercurialLog log)
        {
            Left = left;
            Right = right;
            LeftOnly = left.Results.ExceptBy(right.Results, result => result.FullyQualifiedMethod);
            RightOnly = right.Results.ExceptBy(left.Results, result => result.FullyQualifiedMethod);

            var pairs = (from l in left.Results
                         join r in right.Results on l.FullyQualifiedMethod equals r.FullyQualifiedMethod
                         select new BenchmarkPair(l, r)).ToList();

            LeftBetter = pairs.Where(pair => pair.Percent < ImprovementThreshold).ToList();
            RightBetter = pairs.Where(pair => pair.Percent > RegressionThreshold).ToList();

            var earlier = left.StartTime < right.StartTime ? left : right;
            var later = left.StartTime < right.StartTime ? right : left;

            var earlierHash = BenchmarkRepository.HashForLabel(earlier.Label);
            var laterHash = BenchmarkRepository.HashForLabel(later.Label);
            LogEntries = log.EntriesBetween(earlierHash, laterHash).ToList();
        }
        public TrivialDependencyResolver()
        {
            string root          = HostingEnvironment.ApplicationPhysicalPath;
            string benchmarkData = Path.Combine(root, "benchmarkdata");

            /*
             * repositoryWatcher = new FileWatchingReloader<BenchmarkRepository>(
             *  Path.Combine(benchmarkData, "index.txt"),
             *  () => BenchmarkRepository.Load(benchmarkData),
             *  ReloadTime);*/
            repositoryWatcher = new FileWatchingReloader <BenchmarkRepository>(
                Path.Combine(benchmarkData, "benchmarks.xml"),
                () => BenchmarkRepository.LoadSingleFile(Path.Combine(benchmarkData, "benchmarks.xml")),
                ReloadTime);
            string hgLogFile  = Path.Combine(root, "hg-log.xml");
            string gitLogFile = Path.Combine(root, "git-log.txt");
            var    hgWatcher  = new FileWatchingReloader <ImmutableList <SourceLogEntry> >(hgLogFile, () => MercurialLog.Load(hgLogFile), ReloadTime);
            var    gitWatcher = new FileWatchingReloader <ImmutableList <SourceLogEntry> >(gitLogFile, () => GitLog.Load(gitLogFile), ReloadTime);

            logWatcher = new CombiningReloader <ImmutableList <SourceLogEntry> >(new[] { hgWatcher, gitWatcher }.ToImmutableList(), logs => logs.SelectMany(x => x).OrderByDescending(x => x.Date).ToImmutableList());
        }
 public BenchmarksController(BenchmarkRepository repository, ImmutableList <SourceLogEntry> log)
 {
     this.repository = repository;
     this.log        = log;
 }
示例#11
0
 public TryGetTotalByBasket_IBasketResolver(BenchmarkInitializer initializer, BenchmarkRepository benchmarkRepository, String benchmarkId)
 {
     this.benchmarkRepository = benchmarkRepository;
     this.initializer         = initializer;
     this.benchmarkId         = benchmarkId;
 }
示例#12
0
        protected Decimal?TryGetTotalByBasketOnceResolved(IBasket basket, String benchmarkId, BenchmarkRepository benchmarkRepository)
        {
            var resolver = new TryGetTotalByBasket_IBasketResolver(this, benchmarkRepository, benchmarkId);

            basket.Accept(resolver);
            return(resolver.Result);
        }
示例#13
0
 public DashboardController(BenchmarkRepository repository)
 {
     _repository = repository;
 }