add basic benchmark package (most useful stuff still missing)

Author: sahib

bench/bench.go

@@ -0,0 +1,103 @@
+package bench
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math/rand"
+
+	"github.com/sahib/brig/client"
+	"github.com/sahib/brig/client/clienttest"
+	"github.com/sahib/brig/repo/hints"
+	"github.com/sahib/brig/server"
+	"github.com/sahib/brig/util/testutil"
+)
+
+type Bench interface {
+	SupportHints() bool
+	SetHint(hint hints.Hint) error
+	Process(r io.Reader) error
+	Close() error
+}
+
+//////////
+
+type NullBench struct{}
+
+func NewNullBench() NullBench {
+	return NullBench{}
+}
+
+func (n NullBench) SupportHints() bool            { return false }
+func (n NullBench) SetHint(hint hints.Hint) error { return nil }
+
+func (n NullBench) Process(r io.Reader) error {
+	// NOTE: Use DumbCopy, since io.Copy would use the
+	// ReadFrom of ioutil.Discard. This is lightning fast.
+	// We want to measure actual time to copy in memory.
+	_, err := testutil.DumbCopy(ioutil.Discard, r, false, false)
+	return err
+}
+
+func (n NullBench) Close() error { return nil }
+
+//////////
+
+// TODO: Make backend configurable we can also test with ipfs.
+
+type ServerStageBench struct {
+	daemon *server.Server
+	client *client.Client
+}
+
+func NewServerStageBench() (*ServerStageBench, error) {
+	srv, err := clienttest.StartDaemon("ali", "mock")
+	if err != nil {
+		return nil, err
+	}
+
+	ctl, err := client.Dial(context.Background(), srv.DaemonURL())
+	if err != nil {
+		return nil, err
+	}
+
+	return &ServerStageBench{
+		daemon: srv,
+		client: ctl,
+	}, nil
+}
+
+func (s *ServerStageBench) SupportHints() bool { return true }
+
+func (s *ServerStageBench) SetHint(hint hints.Hint) error {
+	c := string(hint.CompressionAlgo)
+	e := string(hint.EncryptionAlgo)
+	return s.client.HintSet("/", &c, &e)
+}
+
+func (s *ServerStageBench) Process(r io.Reader) error {
+	path := fmt.Sprintf("/path_%d", rand.Int31())
+	return s.client.StageFromReader(path, r)
+}
+
+func (s *ServerStageBench) Close() error {
+	s.daemon.Close()
+	s.client.Close()
+	return nil
+}
+
+// TODO: brig-stage-ipfs
+// TODO: ipfs add
+// TODO: fuse-write
+
+func BenchByName(name string) (Bench, error) {
+	switch name {
+	case "null":
+		return NewNullBench(), nil
+	case "brig-stage":
+		return NewServerStageBench()
+	default:
+		return nil, fmt.Errorf("no such bench: %s", name)
+	}
+}

bench/inputs.go

@@ -0,0 +1,51 @@
+package bench
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"github.com/sahib/brig/util/testutil"
+)
+
+type Input interface {
+	Reader() (io.Reader, error)
+	Close() error
+}
+
+//////////
+
+type NullInput struct {
+	buf []byte
+}
+
+func NewNullInput(size uint64, isRandom bool) *NullInput {
+	var buf []byte
+
+	if isRandom {
+		buf = testutil.CreateRandomDummyBuf(int64(size), 23)
+	} else {
+		buf = testutil.CreateDummyBuf(int64(size))
+	}
+
+	return &NullInput{buf: buf}
+}
+
+func (ni *NullInput) Reader() (io.Reader, error) {
+	return bytes.NewReader(ni.buf), nil
+}
+
+func (ni *NullInput) Close() error {
+	return nil
+}
+
+//////////
+
+func InputByName(name string, size uint64, isRandom bool) (Input, error) {
+	switch name {
+	case "null":
+		return NewNullInput(size, isRandom), nil
+	default:
+		return nil, fmt.Errorf("no such input: %s", name)
+	}
+}

bench/runner.go

@@ -0,0 +1,149 @@
+package bench
+
+import (
+	"sort"
+	"time"
+
+	"github.com/sahib/brig/repo/hints"
+)
+
+type Config struct {
+	InputName   string `json:"input_name"`
+	BenchName   string `json:"bench_name"`
+	Size        uint64 `json:"size"`
+	Random      bool   `json:"random"`
+	Encryption  string
+	Compression string
+}
+
+type Result struct {
+	Config      Config        `json:"config"`
+	Encryption  string        `json:"encryption"`
+	Compression string        `json:"compression"`
+	Took        time.Duration `json:"took"`
+}
+
+func withTiming(fn func() error) (time.Duration, error) {
+	start := time.Now()
+	if err := fn(); err != nil {
+		return time.Since(start), err
+	}
+
+	return time.Since(start), nil
+}
+
+// buildHints handles wildcards for compression and/or encryption.
+// If no wildcards are specified, we just take what is set in `cfg`.
+func buildHints(cfg Config) []hints.Hint {
+	encIsWildcard := cfg.Encryption == "*"
+	zipIsWildcard := cfg.Compression == "*"
+
+	if encIsWildcard && zipIsWildcard {
+		return hints.AllPossibleHints()
+	}
+
+	if encIsWildcard {
+		hs := []hints.Hint{}
+		for _, encAlgo := range hints.ValidEncryptionHints() {
+			hs = append(hs, hints.Hint{
+				CompressionAlgo: hints.CompressionHint(cfg.Compression),
+				EncryptionAlgo:  hints.EncryptionHint(encAlgo),
+			})
+		}
+
+		return hs
+	}
+
+	if zipIsWildcard {
+		hs := []hints.Hint{}
+		for _, zipAlgo := range hints.ValidCompressionHints() {
+			hs = append(hs, hints.Hint{
+				CompressionAlgo: hints.CompressionHint(zipAlgo),
+				EncryptionAlgo:  hints.EncryptionHint(cfg.Encryption),
+			})
+		}
+
+		return hs
+	}
+
+	return []hints.Hint{{
+		CompressionAlgo: hints.CompressionHint(cfg.Compression),
+		EncryptionAlgo:  hints.EncryptionHint(cfg.Encryption),
+	}}
+}
+
+func sortHints(hs []hints.Hint) []hints.Hint {
+	sort.Slice(hs, func(i, j int) bool {
+		return hs[i].Less(hs[j])
+	})
+
+	// sorts in-place, but also return for ease of use.
+	return hs
+}
+
+func benchmarkSingle(cfg Config, fn func(result Result)) error {
+	in, err := InputByName(cfg.InputName, cfg.Size, cfg.Random)
+	if err != nil {
+		return err
+	}
+
+	defer in.Close()
+
+	out, err := BenchByName(cfg.BenchName)
+	if err != nil {
+		return err
+	}
+
+	defer out.Close()
+
+	for _, hint := range sortHints(buildHints(cfg)) {
+		supportsHints := out.SupportHints()
+		if supportsHints {
+			if err := out.SetHint(hint); err != nil {
+				return err
+			}
+		} else {
+			// Indicate in output that nothing was encrypted or compressed.
+			hint.CompressionAlgo = hints.CompressionNone
+			hint.EncryptionAlgo = hint.EncryptionAlgo
+		}
+
+		r, err := in.Reader()
+		if err != nil {
+			return err
+		}
+
+		took, err := withTiming(func() error {
+			return out.Process(r)
+		})
+
+		if err != nil {
+			return err
+		}
+
+		fn(Result{
+			Encryption:  string(hint.EncryptionAlgo),
+			Compression: string(hint.CompressionAlgo),
+			Config:      cfg,
+			Took:        took,
+		})
+
+		if !supportsHints {
+			// If there are no hints there is no point.
+			// of repeating the benchmark several times.
+			break
+		}
+	}
+
+	return nil
+}
+
+func Benchmark(cfgs []Config, fn func(result Result)) error {
+	for _, cfg := range cfgs {
+		if err := benchmarkSingle(cfg, fn); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}