benchmark_test.go

package bench_test

import (
	"crypto/rand"
	"fmt"
	"os"
	"testing"

	"code.cloudfoundry.org/loggregator/doppler/internal/grpcmanager/v1"
	"code.cloudfoundry.org/loggregator/plumbing"
	"github.com/apoydence/pubsub"
	"github.com/apoydence/pubsub/pubsub-gen/setters"
	"github.com/cloudfoundry/sonde-go/events"
	"github.com/gogo/protobuf/proto"
)

//go:generate pubsub-gen --include-pkg-name --imports github.com/cloudfoundry/sonde-go/events --output=$GOPATH/src/code.cloudfoundry.org/loggregator/doppler/internal/test/traverser_test.go -package=bench_test --pointer --struct-name=github.com/cloudfoundry/sonde-go/events.Envelope --traverser=EnvelopeTrav --blacklist-fields=*.XXX_unrecognized,Envelope.EventType,HttpStartStop.PeerType,HttpStartStop.Method,LogMessage.MessageType

var (
	gen func() *events.Envelope
	ps  *pubsub.PubSub
	r   *v1.Router
)

const numOfSubs = 50000

func TestMain(m *testing.M) {
	gen = randEnvGen()

	ps = pubsub.New()
	sub1 := NopSub{}
	trav := NewEnvelopeTrav()

	for i := 0; i < numOfSubs; i++ {
		ps.Subscribe(sub1, pubsub.WithPath(trav.CreatePath(&EnvelopeFilter{
			LogMessage: &LogMessageFilter{
				AppId: setters.String(fmt.Sprintf("%d", i%5)),
			},
		})))
	}

	r = v1.NewRouter()
	setter := NopSetter{}

	for i := 0; i < numOfSubs; i++ {
		r.Register(&plumbing.SubscriptionRequest{Filter: &plumbing.Filter{
			AppID:   fmt.Sprintf("%d", i%5),
			Message: &plumbing.Filter_Log{&plumbing.LogFilter{}},
		}}, setter)
	}

	os.Exit(m.Run())
}

func BenchmarkPubSub(b *testing.B) {
	defer b.ReportAllocs()
	trav := NewEnvelopeTrav()

	for i := 0; i < b.N; i++ {
		ps.Publish(gen(), trav)
	}
}

func BenchmarkDopplerRouter(b *testing.B) {
	defer b.ReportAllocs()

	for i := 0; i < b.N; i++ {
		e := gen()
		r.SendTo(e.GetLogMessage().GetAppId(), e)
	}
}

type NopSetter struct{}

func (s NopSetter) Set(data []byte) {}

type NopSub struct{}

func (s NopSub) Write(data interface{}) {}

func randEnvGen() func() *events.Envelope {
	var s []*events.Envelope
	for i := 0; i < 100; i++ {
		buf := make([]byte, 10)
		rand.Read(buf)
		s = append(s, buildLogMessage(fmt.Sprintf("%d", i%5), buf))
	}

	var i int
	return func() *events.Envelope {
		i++
		return s[i%len(s)]
	}
}

func buildLogMessage(appID string, payload []byte) *events.Envelope {
	return &events.Envelope{
		Origin:     proto.String("some-origin"),
		EventType:  events.Envelope_LogMessage.Enum(),
		Deployment: proto.String("some-deployment"),
		Job:        proto.String("some-job"),
		Index:      proto.String("some-index"),
		Ip:         proto.String("some-ip"),
		LogMessage: &events.LogMessage{
			Message:        payload,
			MessageType:    events.LogMessage_OUT.Enum(),
			Timestamp:      proto.Int64(99),
			AppId:          proto.String(appID),
			SourceType:     proto.String("test-source-type"),
			SourceInstance: proto.String("test-source-instance"),
		},
	}
}

go test -bench=. -run=NoTest
BenchmarkPubSub-8          	   50000	     29984 ns/op	     960 B/op	      45 allocs/op
BenchmarkDopplerRouter-8   	   50000	     30329 ns/op	     128 B/op	       1 allocs/op
PASS
ok  	code.cloudfoundry.org/loggregator/doppler/internal/test	3.770s