blob: c60cefd7e45763a63cf047bb0746ed110ccbcbc2 [file] [log] [blame]
// Copyright 2017 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.
package app
import (
"bytes"
"errors"
"fmt"
"html/template"
"io/ioutil"
"net/http"
"path/filepath"
"sort"
"strconv"
"strings"
"unicode"
"golang.org/x/perf/benchstat"
"golang.org/x/perf/storage/benchfmt"
"golang.org/x/perf/storage/query"
)
// A resultGroup holds a list of results and tracks the distinct labels found in that list.
type resultGroup struct {
// The (partial) query string that resulted in this group.
Q string
// Raw list of results.
results []*benchfmt.Result
// LabelValues is the count of results found with each distinct (key, value) pair found in labels.
// A value of "" counts results missing that key.
LabelValues map[string]valueSet
}
// add adds res to the resultGroup.
func (g *resultGroup) add(res *benchfmt.Result) {
g.results = append(g.results, res)
if g.LabelValues == nil {
g.LabelValues = make(map[string]valueSet)
}
for k, v := range res.Labels {
if g.LabelValues[k] == nil {
g.LabelValues[k] = make(valueSet)
if len(g.results) > 1 {
g.LabelValues[k][""] = len(g.results) - 1
}
}
g.LabelValues[k][v]++
}
for k := range g.LabelValues {
if res.Labels[k] == "" {
g.LabelValues[k][""]++
}
}
}
// splitOn returns a new set of groups sharing a common value for key.
func (g *resultGroup) splitOn(key string) []*resultGroup {
groups := make(map[string]*resultGroup)
var values []string
for _, res := range g.results {
value := res.Labels[key]
if groups[value] == nil {
groups[value] = &resultGroup{Q: key + ":" + value}
values = append(values, value)
}
groups[value].add(res)
}
sort.Strings(values)
var out []*resultGroup
for _, value := range values {
out = append(out, groups[value])
}
return out
}
// valueSet is a set of values and the number of results with each value.
type valueSet map[string]int
// valueCount and byCount are used for sorting a valueSet
type valueCount struct {
Value string
Count int
}
type byCount []valueCount
func (s byCount) Len() int { return len(s) }
func (s byCount) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s byCount) Less(i, j int) bool {
if s[i].Count != s[j].Count {
return s[i].Count > s[j].Count
}
return s[i].Value < s[j].Value
}
// TopN returns a slice containing n valueCount entries, and if any labels were omitted, an extra entry with value "…".
func (vs valueSet) TopN(n int) []valueCount {
var s []valueCount
var total int
for v, count := range vs {
s = append(s, valueCount{v, count})
total += count
}
sort.Sort(byCount(s))
out := s
if len(out) > n {
out = s[:n]
}
if len(out) < len(s) {
var outTotal int
for _, vc := range out {
outTotal += vc.Count
}
out = append(out, valueCount{"…", total - outTotal})
}
return out
}
// addToQuery returns a new query string with add applied as a filter.
func addToQuery(query, add string) string {
if strings.ContainsAny(add, " \t\\\"") {
add = strings.Replace(add, `\`, `\\`, -1)
add = strings.Replace(add, `"`, `\"`, -1)
add = `"` + add + `"`
}
if strings.Contains(query, "|") {
return add + " " + query
}
return add + " | " + query
}
// compare handles queries that require comparison of the groups in the query.
func (a *App) compare(w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
http.Error(w, err.Error(), 500)
return
}
q := r.Form.Get("q")
tmpl, err := ioutil.ReadFile(filepath.Join(a.BaseDir, "template/compare.html"))
if err != nil {
http.Error(w, err.Error(), 500)
return
}
t, err := template.New("main").Funcs(template.FuncMap{
"addToQuery": addToQuery,
}).Parse(string(tmpl))
if err != nil {
http.Error(w, err.Error(), 500)
return
}
data := a.compareQuery(q)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if err := t.Execute(w, data); err != nil {
http.Error(w, err.Error(), 500)
return
}
}
type compareData struct {
Q string
Error string
Benchstat template.HTML
Groups []*resultGroup
Labels map[string]bool
CommonLabels benchfmt.Labels
}
// queryKeys returns the keys that are exact-matched by q.
func queryKeys(q string) map[string]bool {
out := make(map[string]bool)
for _, part := range query.SplitWords(q) {
// TODO(quentin): This func is shared with db.go; refactor?
i := strings.IndexFunc(part, func(r rune) bool {
return r == ':' || r == '>' || r == '<' || unicode.IsSpace(r) || unicode.IsUpper(r)
})
if i >= 0 && part[i] == ':' {
out[part[:i]] = true
}
}
return out
}
// elideKeyValues returns content, a benchmark format line, with the
// values of any keys in keys elided.
func elideKeyValues(content string, keys map[string]bool) string {
var end string
if i := strings.IndexFunc(content, unicode.IsSpace); i >= 0 {
content, end = content[:i], content[i:]
}
// Check for gomaxprocs value
if i := strings.LastIndex(content, "-"); i >= 0 {
_, err := strconv.Atoi(content[i+1:])
if err == nil {
if keys["gomaxprocs"] {
content, end = content[:i], "-*"+end
} else {
content, end = content[:i], content[i:]+end
}
}
}
parts := strings.Split(content, "/")
for i, part := range parts {
if equals := strings.Index(part, "="); equals >= 0 {
if keys[part[:equals]] {
parts[i] = part[:equals] + "=*"
}
} else if i == 0 {
if keys["name"] {
parts[i] = "Benchmark*"
}
} else if keys[fmt.Sprintf("sub%d", i)] {
parts[i] = "*"
}
}
return strings.Join(parts, "/") + end
}
// fetchCompareResults fetches the matching results for a given query string.
// The results will be grouped into one or more groups based on either the query string or heuristics.
func (a *App) fetchCompareResults(q string) ([]*resultGroup, error) {
// Parse query
prefix, queries := parseQueryString(q)
// Send requests
// TODO(quentin): Issue requests in parallel?
var groups []*resultGroup
var found int
for _, qPart := range queries {
keys := queryKeys(qPart)
group := &resultGroup{Q: qPart}
if prefix != "" {
qPart = prefix + " " + qPart
}
res := a.StorageClient.Query(qPart)
for res.Next() {
result := res.Result()
result.Content = elideKeyValues(result.Content, keys)
group.add(result)
found++
}
err := res.Err()
res.Close()
if err != nil {
// TODO: If the query is invalid, surface that to the user.
return nil, err
}
groups = append(groups, group)
}
if found == 0 {
return nil, errors.New("no results matched the query string")
}
// Attempt to automatically split results.
if len(groups) == 1 {
group := groups[0]
// Matching a single upload with multiple files -> split by file
if len(group.LabelValues["upload"]) == 1 && len(group.LabelValues["upload-part"]) > 1 {
groups = group.splitOn("upload-part")
}
}
return groups, nil
}
func (a *App) compareQuery(q string) *compareData {
if len(q) == 0 {
return &compareData{}
}
groups, err := a.fetchCompareResults(q)
if err != nil {
return &compareData{
Q: q,
Error: err.Error(),
}
}
var buf bytes.Buffer
// Compute benchstat
c := &benchstat.Collection{
AddGeoMean: true,
}
for _, g := range groups {
c.AddResults(g.Q, g.results)
}
benchstat.FormatHTML(&buf, c.Tables())
// Prepare struct for template.
labels := make(map[string]bool)
// commonLabels are the key: value of every label that has an
// identical value on every result.
commonLabels := make(benchfmt.Labels)
// Scan the first group for common labels.
for k, vs := range groups[0].LabelValues {
if len(vs) == 1 {
for v := range vs {
commonLabels[k] = v
}
}
}
// Remove any labels not common in later groups.
for _, g := range groups[1:] {
for k, v := range commonLabels {
if len(g.LabelValues[k]) != 1 || g.LabelValues[k][v] == 0 {
delete(commonLabels, k)
}
}
}
// List all labels present and not in commonLabels.
for _, g := range groups {
for k := range g.LabelValues {
if commonLabels[k] != "" {
continue
}
labels[k] = true
}
}
data := &compareData{
Q: q,
Benchstat: template.HTML(buf.String()),
Groups: groups,
Labels: labels,
CommonLabels: commonLabels,
}
return data
}
// textCompare is called if benchsave is requesting a text-only analysis.
func (a *App) textCompare(w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
http.Error(w, err.Error(), 500)
return
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
q := r.Form.Get("q")
groups, err := a.fetchCompareResults(q)
if err != nil {
// TODO(quentin): Should we serve this with a 500 or 404? This means the query was invalid or had no results.
fmt.Fprintf(w, "unable to analyze results: %v", err)
}
// Compute benchstat
c := new(benchstat.Collection)
for _, g := range groups {
c.AddResults(g.Q, g.results)
}
benchstat.FormatText(w, c.Tables())
}