first time born now here

Author: codingberg

format.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+)
+
+// graphData translate bench results to Google graph JSON structure
+func graphData(benchResults BenchNameSet, oBenchNames, oBenchArgs stringList) []byte {
+	data := new(bytes.Buffer)
+
+	data.WriteString("[")
+	sep := ""
+	data.WriteString("[\"Argument\"")
+	for _, oName := range oBenchNames {
+		sep = ","
+		data.WriteString(fmt.Sprintf("%s\"%s\"", sep, oName))
+	}
+	data.WriteString("]")
+
+	lsep := ""
+	for _, oArg := range oBenchArgs {
+		lsep = ","
+		data.WriteString(fmt.Sprintf("%s[\"%s\"", lsep, oArg))
+		sep := ""
+		for _, oName := range oBenchNames {
+			sep = ","
+			data.WriteString(fmt.Sprintf("%s%.2f", sep, benchResults[oName][oArg]))
+		}
+		data.WriteString("]")
+	}
+	data.WriteString("]")
+
+	return data.Bytes()
+}

list.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+type stringList []string
+
+func (list *stringList) String() string {
+	return fmt.Sprint(*list)
+}
+
+func (list *stringList) Set(value string) error {
+	for _, elem := range strings.Split(value, ",") {
+		list.Add(elem)
+	}
+	return nil
+}
+
+func (list *stringList) Add(value string) error {
+	*list = append(*list, value)
+	return nil
+}
+
+func (list *stringList) Len() int {
+	return len(*list)
+}
+
+func (list *stringList) stringInList(a string) bool {
+	for _, b := range *list {
+		if b == a {
+			return true
+		}
+	}
+	return false
+}

main.go

@@ -0,0 +1,128 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+
+	"github.com/fatih/color"
+	"golang.org/x/tools/benchmark/parse"
+)
+
+// uploadData sends data to server and expects graph url.
+func uploadData(apiUrl, data, title string) (string, error) {
+
+	resp, err := http.PostForm(apiUrl, url.Values{"data": {data}, "title": {title}})
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	if resp.StatusCode != 200 {
+		return "", errors.New("Server din't return graph URL")
+	}
+
+	return string(body), nil
+}
+
+func main() {
+
+	var oBenchNames, oBenchArgs stringList
+
+	// graph elements will be ordered as in benchmark output by default - unless the order was specified here
+	flag.Var(&oBenchNames, "obn", "comma-separated list of benchmark names")
+	flag.Var(&oBenchArgs, "oba", "comma-separated list of benchmark arguments")
+	title := flag.String("title", "Graph: Benchmark results in ns/op", "title of a graph")
+	apiUrl := flag.String("apiurl", "http://benchgraph.codingberg.com", "url to server api")
+	flag.Parse()
+
+	var skipBenchNamesParsing, skipBenchArgsParsing bool
+
+	if oBenchNames.Len() > 0 {
+		skipBenchNamesParsing = true
+	}
+	if oBenchArgs.Len() > 0 {
+		skipBenchArgsParsing = true
+	}
+
+	benchResults := make(BenchNameSet)
+
+	// parse Golang benchmark results, line by line
+	scan := bufio.NewScanner(os.Stdin)
+	green := color.New(color.FgGreen).SprintfFunc()
+	red := color.New(color.FgRed).SprintFunc()
+	for scan.Scan() {
+		line := scan.Text()
+
+		mark := green("√")
+
+		b, err := parse.ParseLine(line)
+		if err != nil {
+			mark = red("?")
+		}
+
+		// read bench name and arguments
+		if b != nil {
+			name, arg, _, err := parseNameArgThread(b.Name)
+			if err != nil {
+				mark = red("!")
+				fmt.Printf("%s %s\n", mark, line)
+				continue
+			}
+
+			if !skipBenchNamesParsing && !oBenchNames.stringInList(name) {
+				oBenchNames.Add(name)
+			}
+
+			if !skipBenchArgsParsing && !oBenchArgs.stringInList(arg) {
+				oBenchArgs.Add(arg)
+			}
+
+			if _, ok := benchResults[name]; !ok {
+				benchResults[name] = make(BenchArgSet)
+			}
+
+			benchResults[name][arg] = b.NsPerOp
+		}
+
+		fmt.Printf("%s %s\n", mark, line)
+	}
+
+	if err := scan.Err(); err != nil {
+		fmt.Fprintf(os.Stderr, "reading standard input: %v", err)
+		os.Exit(1)
+	}
+
+	if len(benchResults) == 0 {
+		fmt.Fprintf(os.Stderr, "no data to show.\n\n")
+		os.Exit(1)
+	}
+
+	fmt.Println()
+	fmt.Println("Waiting for server response ...")
+
+	data := graphData(benchResults, oBenchNames, oBenchArgs)
+
+	graphUrl, err := uploadData(*apiUrl, string(data), *title)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "uploading data: %v", err)
+		os.Exit(1)
+	}
+
+	fmt.Println("=========================================")
+	fmt.Println()
+	fmt.Println(graphUrl)
+	fmt.Println()
+	fmt.Println("=========================================")
+
+}

main_test.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"testing"
+
+	"golang.org/x/tools/benchmark/parse"
+)
+
+var bTests = []struct {
+	line    string // input
+	name    string // expected result
+	arg     string
+	nsperop float64
+}{
+	{"BenchmarkF2_F0000000-4		50000000	        29.4 ns/op", "F2", "F0000000", 29.4},
+	{"BenchmarkF0_FF-2		10000000	        37.4 ns/op", "F0", "FF", 37.4},
+	{"BenchmarkF_0-2		40000000	        11.2 ns/op", "F", "0", 11.2},
+}
+
+func TestParser(t *testing.T) {
+	for _, tt := range bTests {
+		b, _ := parse.ParseLine(tt.line)
+		name, arg, _, _ := parseNameArgThread(b.Name)
+		if name != tt.name {
+			t.Errorf("parseNameArgThread(%s): expected %s, actual %s", b.Name, tt.name, name)
+		}
+		if arg != tt.arg {
+			t.Errorf("parseNameArgThread(%s): expected %s, actual %s", b.Name, tt.arg, arg)
+		}
+		if b.NsPerOp != tt.nsperop {
+			t.Errorf("parseNameArgThread(%s): expected %f, actual %f", b.Name, tt.nsperop, b.NsPerOp)
+		}
+	}
+}

parse.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"errors"
+	"regexp"
+	"strconv"
+)
+
+// Coder should use following naming convention for Benchmark functions
+// Naming convention: Benchmark[Function_name]_[Function_argument](b *testing.B)
+var re *regexp.Regexp = regexp.MustCompile(`Benchmark([a-zA-Z0-9]+)_([_a-zA-Z0-9]+)-([0-9]+)$`)
+
+// Storage for Func(Arg)=Result relations
+type BenchArgSet map[string]float64
+type BenchNameSet map[string]BenchArgSet
+
+// parseNameArgThread parses function name, argument and number of threads from benchmark output.
+func parseNameArgThread(line string) (name string, arg string, c int, err error) {
+
+	arr := re.FindStringSubmatch(line)
+
+	// we expect 4 columns
+	if len(arr) != 4 {
+		return "", "", 0, errors.New("Can't parse benchmark result")
+	}
+
+	name, arg = arr[1], arr[2]
+
+	c, err = strconv.Atoi(arr[3])
+	if err != nil {
+		return "", "", 0, errors.New("Can't parse benchmark result")
+	}
+
+	return name, arg, c, nil
+}