go/dashboard/app/build/perf_graph.go

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// +build appengine

package build

import (
	"bytes"
	"fmt"
	"html/template"
	"net/http"
	"strconv"

	"appengine"
	"appengine/datastore"
)

func init() {
	for _, d := range dashboards {
		http.HandleFunc(d.RelPath+"perfgraph", perfGraphHandler)
	}
}

func perfGraphHandler(w http.ResponseWriter, r *http.Request) {
	d := dashboardForRequest(r)
	c := d.Context(appengine.NewContext(r))
	pc, err := GetPerfConfig(c, r)
	if err != nil {
		logErr(w, r, err)
		return
	}
	allBuilders := pc.BuildersForBenchmark("")
	allBenchmarks := pc.BenchmarksForBuilder("")
	allMetrics := pc.MetricsForBenchmark("")
	allProcs := pc.ProcList("")
	r.ParseForm()
	absolute := r.FormValue("absolute") != ""
	selBuilders := r.Form["builder"]
	selBenchmarks := r.Form["benchmark"]
	selMetrics := r.Form["metric"]
	selProcs := r.Form["procs"]
	if len(selBuilders) == 0 {
		selBuilders = append(selBuilders, allBuilders[0])
	}
	if len(selBenchmarks) == 0 {
		selBenchmarks = append(selBenchmarks, "json")
	}
	if len(selMetrics) == 0 {
		selMetrics = append(selMetrics, "time")
	}
	if len(selProcs) == 0 {
		selProcs = append(selProcs, "1")
	}
	// TODO(dvyukov): validate input

	present := func(set []string, s string) bool {
		for _, s1 := range set {
			if s1 == s {
				return true
			}
		}
		return false
	}

	cfg := &uiPerfConfig{}
	for _, v := range allBuilders {
		cfg.Builders = append(cfg.Builders, uiPerfConfigElem{v, present(selBuilders, v)})
	}
	for _, v := range allBenchmarks {
		cfg.Benchmarks = append(cfg.Benchmarks, uiPerfConfigElem{v, present(selBenchmarks, v)})
	}
	for _, v := range allMetrics {
		cfg.Metrics = append(cfg.Metrics, uiPerfConfigElem{v, present(selMetrics, v)})
	}
	for _, v := range allProcs {
		cfg.Procs = append(cfg.Procs, uiPerfConfigElem{strconv.Itoa(v), present(selProcs, strconv.Itoa(v))})
	}

	// Select last commit.
	startCommit := 0
	commitsToDisplay := 100
	if r.FormValue("startcommit") != "" {
		startCommit, _ = strconv.Atoi(r.FormValue("startcommit"))
		commitsToDisplay, _ = strconv.Atoi(r.FormValue("commitnum"))
	} else {
		var commits1 []*Commit
		_, err = datastore.NewQuery("Commit").
			Ancestor((&Package{}).Key(c)).
			Order("-Num").
			Filter("NeedsBenchmarking =", true).
			Limit(1).
			GetAll(c, &commits1)
		if err != nil || len(commits1) != 1 {
			logErr(w, r, err)
			return
		}
		startCommit = commits1[0].Num
	}

	if r.FormValue("zoomin") != "" {
		commitsToDisplay /= 2
	} else if r.FormValue("zoomout") != "" {
		commitsToDisplay *= 2
	} else if r.FormValue("older") != "" {
		startCommit -= commitsToDisplay / 2
	} else if r.FormValue("newer") != "" {
		startCommit += commitsToDisplay / 2
	}

	// TODO(dvyukov): limit number of lines on the graph?
	startCommitNum := startCommit - commitsToDisplay + 1
	if startCommitNum < 0 {
		startCommitNum = 0
	}
	var vals [][]float64
	var hints [][]string
	var certainty [][]bool
	var headers []string
	commits2, err := GetCommits(c, startCommitNum, commitsToDisplay)
	if err != nil {
		logErr(w, r, err)
		return
	}
	for _, builder := range selBuilders {
		for _, metric := range selMetrics {
			for _, benchmark := range selBenchmarks {
				for _, procs := range selProcs {
					benchProcs := fmt.Sprintf("%v-%v", benchmark, procs)
					vv, err := GetPerfMetricsForCommits(c, builder, benchProcs, metric, startCommitNum, commitsToDisplay)
					if err != nil {
						logErr(w, r, err)
						return
					}
					nonzero := false
					min := ^uint64(0)
					max := uint64(0)
					for _, v := range vv {
						if v == 0 {
							continue
						}
						if max < v {
							max = v
						}
						if min > v {
							min = v
						}
						nonzero = true
					}
					if nonzero {
						noise := pc.NoiseLevel(builder, benchProcs, metric)
						diff := (float64(max) - float64(min)) / float64(max) * 100
						// Scale graph passes through 2 points: (noise, minScale) and (growthFactor*noise, 100).
						// Plus it's bottom capped at minScale and top capped at 100.
						// Intention:
						// Diffs below noise are scaled to minScale.
						// Diffs above growthFactor*noise are scaled to 100.
						// Between noise and growthFactor*noise scale growths linearly.
						const minScale = 5
						const growthFactor = 4
						scale := diff*(100-minScale)/(noise*(growthFactor-1)) + (minScale*growthFactor-100)/(growthFactor-1)
						if scale < minScale {
							scale = minScale
						}
						if scale > 100 {
							scale = 100
						}
						descBuilder := "/" + builder
						descBenchmark := "/" + benchProcs
						descMetric := "/" + metric
						if len(selBuilders) == 1 {
							descBuilder = ""
						}
						if len(selBenchmarks) == 1 && len(selProcs) == 1 {
							descBenchmark = ""
						}
						if len(selMetrics) == 1 && (len(selBuilders) > 1 || len(selBenchmarks) > 1 || len(selProcs) > 1) {
							descMetric = ""
						}
						desc := fmt.Sprintf("%v%v%v", descBuilder, descBenchmark, descMetric)[1:]
						hh := make([]string, commitsToDisplay)
						valf := make([]float64, commitsToDisplay)
						cert := make([]bool, commitsToDisplay)
						lastval := uint64(0)
						lastval0 := uint64(0)
						for i, v := range vv {
							cert[i] = true
							if v == 0 {
								if lastval == 0 {
									continue
								}
								nextval := uint64(0)
								nextidx := 0
								for i2, v2 := range vv[i+1:] {
									if v2 != 0 {
										nextval = v2
										nextidx = i + i2 + 1
										break
									}
								}
								if nextval == 0 {
									continue
								}
								cert[i] = false
								v = lastval + uint64(int64(nextval-lastval)/int64(nextidx-i+1))
								_, _ = nextval, nextidx
							}
							f := float64(v)
							if !absolute {
								f = (float64(v) - float64(min)) * 100 / (float64(max) - float64(min))
								f = f*scale/100 + (100-scale)/2
								f += 0.000001
							}
							valf[i] = f
							com := commits2[i]
							comLink := "https://code.google.com/p/go/source/detail?r=" + com.Hash
							if cert[i] {
								d := ""
								if lastval0 != 0 {
									d = fmt.Sprintf(" (%.02f%%)", perfDiff(lastval0, v))
								}
								cmpLink := fmt.Sprintf("/perfdetail?commit=%v&builder=%v&benchmark=%v", com.Hash, builder, benchmark)
								hh[i] = fmt.Sprintf("%v: <a href='%v'>%v%v</a><br><a href='%v'>%v</a><br>%v", desc, cmpLink, v, d, comLink, com.Desc, com.Time.Format("Jan 2, 2006 1:04"))
							} else {
								hh[i] = fmt.Sprintf("%v: NO DATA<br><a href='%v'>%v</a><br>%v", desc, comLink, com.Desc, com.Time.Format("Jan 2, 2006 1:04"))
							}
							lastval = v
							if cert[i] {
								lastval0 = v
							}
						}
						vals = append(vals, valf)
						hints = append(hints, hh)
						certainty = append(certainty, cert)
						headers = append(headers, fmt.Sprintf("%s (%.2f%% [%.2f%%])", desc, diff, noise))
					}
				}
			}
		}
	}

	var commits []perfGraphCommit
	if len(vals) != 0 && len(vals[0]) != 0 {
		for i := range vals[0] {
			if !commits2[i].NeedsBenchmarking {
				continue
			}
			var c perfGraphCommit
			for j := range vals {
				c.Vals = append(c.Vals, perfGraphValue{float64(vals[j][i]), certainty[j][i], hints[j][i]})
			}
			commits = append(commits, c)
		}
	}

	data := &perfGraphData{d, cfg, startCommit, commitsToDisplay, absolute, headers, commits}

	var buf bytes.Buffer
	if err := perfGraphTemplate.Execute(&buf, data); err != nil {
		logErr(w, r, err)
		return
	}

	buf.WriteTo(w)
}

var perfGraphTemplate = template.Must(
	template.New("perf_graph.html").ParseFiles("build/perf_graph.html"),
)

type perfGraphData struct {
	Dashboard   *Dashboard
	Config      *uiPerfConfig
	StartCommit int
	CommitNum   int
	Absolute    bool
	Headers     []string
	Commits     []perfGraphCommit
}

type perfGraphCommit struct {
	Name string
	Vals []perfGraphValue
}

type perfGraphValue struct {
	Val       float64
	Certainty bool
	Hint      string
}