// Copyright 2018 The Chromium 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 main
|
|
// This server runs along side the karma tests and listens for POST requests
|
// when any test case reports it has output for Perf. See perfReporter.js
|
// for the browser side part.
|
|
// Unlike the gold ingester, the perf ingester allows multiple reports
|
// of the same benchmark and will output the average of these results
|
// on a call to dump
|
|
import (
|
"encoding/json"
|
"flag"
|
"fmt"
|
"io/ioutil"
|
"log"
|
"net/http"
|
"os"
|
"path"
|
"strconv"
|
"strings"
|
|
"github.com/google/uuid"
|
"go.skia.org/infra/perf/go/ingestcommon"
|
)
|
|
// upload_nano_results looks for anything*.json
|
// We add the random UUID to avoid name clashes when uploading to
|
// the perf bucket (which uploads to folders based on Month/Day/Hour, which can
|
// easily have duplication if multiple perf tasks run in an hour.)
|
var JSON_FILENAME = fmt.Sprintf("%s_browser_bench.json", uuid.New().String())
|
|
var (
|
outDir = flag.String("out_dir", "/OUT/", "location to dump the Perf JSON")
|
port = flag.String("port", "8081", "Port to listen on.")
|
|
botId = flag.String("bot_id", "", "swarming bot id")
|
browser = flag.String("browser", "Chrome", "Browser Key")
|
buildBucketID = flag.Int64("buildbucket_build_id", 0, "Buildbucket build id key")
|
builder = flag.String("builder", "", "Builder, like 'Test-Debian9-EMCC-GCE-CPU-AVX2-wasm-Debug-All-PathKit'")
|
compiledLanguage = flag.String("compiled_language", "wasm", "wasm or asm.js")
|
config = flag.String("config", "Release", "Configuration (e.g. Debug/Release) key")
|
gitHash = flag.String("git_hash", "-", "The git commit hash of the version being tested")
|
hostOS = flag.String("host_os", "Debian9", "OS Key")
|
issue = flag.Int64("issue", 0, "issue (if tryjob)")
|
patch_storage = flag.String("patch_storage", "", "patch storage (if tryjob)")
|
patchset = flag.Int64("patchset", 0, "patchset (if tryjob)")
|
taskId = flag.String("task_id", "", "swarming task id")
|
sourceType = flag.String("source_type", "pathkit", "Gold Source type, like pathkit,canvaskit")
|
)
|
|
// Received from the JS side.
|
type reportBody struct {
|
// a name describing the benchmark. Should be unique enough to allow use of grep.
|
BenchName string `json:"bench_name"`
|
// The number of microseconds of the task.
|
TimeMicroSeconds float64 `json:"time_us"`
|
}
|
|
// The keys to be used at the top level for all Results.
|
var defaultKeys map[string]string
|
|
// contains all the results reported in through report_perf_data
|
var results map[string][]reportBody
|
|
type BenchData struct {
|
Hash string `json:"gitHash"`
|
Issue string `json:"issue"`
|
PatchSet string `json:"patchset"`
|
Key map[string]string `json:"key"`
|
Options map[string]string `json:"options,omitempty"`
|
Results map[string]ingestcommon.BenchResults `json:"results"`
|
PatchStorage string `json:"patch_storage,omitempty"`
|
|
SwarmingTaskID string `json:"swarming_task_id,omitempty"`
|
SwarmingBotID string `json:"swarming_bot_id,omitempty"`
|
}
|
|
func main() {
|
flag.Parse()
|
|
cpuGPU := "CPU"
|
if strings.Index(*builder, "-GPU-") != -1 {
|
cpuGPU = "GPU"
|
}
|
defaultKeys = map[string]string{
|
"arch": "WASM",
|
"browser": *browser,
|
"compiled_language": *compiledLanguage,
|
"compiler": "emsdk",
|
"configuration": *config,
|
"cpu_or_gpu": cpuGPU,
|
"cpu_or_gpu_value": "Browser",
|
"os": *hostOS,
|
"source_type": *sourceType,
|
}
|
|
results = make(map[string][]reportBody)
|
|
http.HandleFunc("/report_perf_data", reporter)
|
http.HandleFunc("/dump_json", dumpJSON)
|
|
fmt.Printf("Waiting for perf ingestion on port %s\n", *port)
|
|
log.Fatal(http.ListenAndServe(":"+*port, nil))
|
}
|
|
// reporter handles when the client reports a test has a benchmark.
|
func reporter(w http.ResponseWriter, r *http.Request) {
|
if r.Method != "POST" {
|
http.Error(w, "Only POST accepted", 400)
|
return
|
}
|
defer r.Body.Close()
|
|
body, err := ioutil.ReadAll(r.Body)
|
if err != nil {
|
http.Error(w, "Malformed body", 400)
|
return
|
}
|
|
benchOutput := reportBody{}
|
if err := json.Unmarshal(body, &benchOutput); err != nil {
|
fmt.Println(err)
|
http.Error(w, "Could not unmarshal JSON", 400)
|
return
|
}
|
|
if _, err := w.Write([]byte("Accepted")); err != nil {
|
fmt.Printf("Could not write response: %s\n", err)
|
return
|
}
|
|
results[benchOutput.BenchName] = append(results[benchOutput.BenchName], benchOutput)
|
}
|
|
// createOutputFile creates a file and set permissions correctly.
|
func createOutputFile(p string) (*os.File, error) {
|
outputFile, err := os.Create(p)
|
if err != nil {
|
return nil, fmt.Errorf("Could not open file %s on disk: %s", p, err)
|
}
|
// Make this accessible (and deletable) by all users
|
if err = outputFile.Chmod(0666); err != nil {
|
return nil, fmt.Errorf("Could not change permissions of file %s: %s", p, err)
|
}
|
return outputFile, nil
|
}
|
|
// dumpJSON writes out a JSON file with all the results, typically at the end of
|
// all the tests. If there is more than one result per benchmark, we report the average.
|
func dumpJSON(w http.ResponseWriter, r *http.Request) {
|
if r.Method != "POST" {
|
http.Error(w, "Only POST accepted", 400)
|
return
|
}
|
|
p := path.Join(*outDir, JSON_FILENAME)
|
outputFile, err := createOutputFile(p)
|
defer outputFile.Close()
|
if err != nil {
|
fmt.Println(err)
|
http.Error(w, "Could not open json file on disk", 500)
|
return
|
}
|
|
benchData := BenchData{
|
Hash: *gitHash,
|
Issue: strconv.FormatInt(*issue, 10),
|
PatchStorage: *patch_storage,
|
PatchSet: strconv.FormatInt(*patchset, 10),
|
Key: defaultKeys,
|
SwarmingBotID: *botId,
|
SwarmingTaskID: *taskId,
|
}
|
|
allResults := make(map[string]ingestcommon.BenchResults)
|
for name, benches := range results {
|
samples := []float64{}
|
total := float64(0)
|
for _, t := range benches {
|
samples = append(samples, t.TimeMicroSeconds)
|
total += t.TimeMicroSeconds
|
}
|
allResults[name] = map[string]ingestcommon.BenchResult{
|
"default": map[string]interface{}{
|
"average_us": total / float64(len(benches)),
|
"samples": samples,
|
},
|
}
|
}
|
benchData.Results = allResults
|
|
enc := json.NewEncoder(outputFile)
|
enc.SetIndent("", " ") // Make it human readable.
|
if err := enc.Encode(&benchData); err != nil {
|
fmt.Println(err)
|
http.Error(w, "Could not write json to disk", 500)
|
return
|
}
|
fmt.Println("JSON Written")
|
}
|
