From 305d6e0fbeefb2018f2241ad4a7c1a8e9d618351 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Thu, 5 Sep 2019 10:01:15 +0700 Subject: [PATCH] make the benchmark suite compatible with Go 1.13 Unfortunately, there doesn't seem to be a way to keep the samples flag. --- .circleci/config.yml | 4 +- .travis/script.sh | 4 +- appveyor.yml | 2 +- benchmark/benchmark_suite_test.go | 12 ++- benchmark/benchmark_test.go | 125 +++++++++++++++--------------- 5 files changed, 77 insertions(+), 70 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 5e50144c..dc0a1d0a 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -25,10 +25,10 @@ jobs: command: go version - run: name: "Run benchmark tests" - command: ginkgo -randomizeAllSpecs -trace benchmark -- -samples=1 + command: ginkgo -randomizeAllSpecs -trace benchmark -- -size=10 - run: name: "Run benchmark tests with race detector" - command: ginkgo -race -randomizeAllSpecs -trace benchmark -- -samples=1 -size=10 + command: ginkgo -race -randomizeAllSpecs -trace benchmark -- -size=5 - run: name: "Run tools tests" command: ginkgo -race -r -v -randomizeAllSpecs -trace integrationtests/tools diff --git a/.travis/script.sh b/.travis/script.sh index e4d7a466..659b5a18 100755 --- a/.travis/script.sh +++ b/.travis/script.sh @@ -16,11 +16,11 @@ fi if [ ${TESTMODE} == "integration" ]; then # run benchmark tests - ginkgo -randomizeAllSpecs -randomizeSuites -trace benchmark -- -samples=1 + ginkgo -randomizeAllSpecs -randomizeSuites -trace benchmark -- -size=10 # run benchmark tests with the Go race detector # The Go race detector only works on amd64. if [ ${TRAVIS_GOARCH} == 'amd64' ]; then - ginkgo -race -randomizeAllSpecs -randomizeSuites -trace benchmark -- -samples=1 -size=10 + ginkgo -race -randomizeAllSpecs -randomizeSuites -trace benchmark -- -size=5 fi # run integration tests ginkgo -r -v -randomizeAllSpecs -randomizeSuites -trace integrationtests diff --git a/appveyor.yml b/appveyor.yml index 0eff3237..44cd6223 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -27,7 +27,7 @@ install: build_script: - ginkgo -r -v -randomizeAllSpecs -randomizeSuites -trace -skipPackage benchmark,integrationtests - - ginkgo -randomizeAllSpecs -randomizeSuites -trace benchmark -- -samples=1 + - ginkgo -randomizeAllSpecs -randomizeSuites -trace benchmark -- -size=10 test: off diff --git a/benchmark/benchmark_suite_test.go b/benchmark/benchmark_suite_test.go index d24ef6be..26df5f92 100644 --- a/benchmark/benchmark_suite_test.go +++ b/benchmark/benchmark_suite_test.go @@ -2,6 +2,7 @@ package benchmark import ( "flag" + "math/rand" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" @@ -15,12 +16,15 @@ func TestBenchmark(t *testing.T) { } var ( - size int // file size in MB, will be read from flags - samples int // number of samples for Measure, will be read from flags + size int // file size in MB, will be read from flags ) func init() { flag.IntVar(&size, "size", 50, "data length (in MB)") - flag.IntVar(&samples, "samples", 6, "number of samples") - flag.Parse() } + +var _ = BeforeSuite(func() { + rand.Seed(GinkgoRandomSeed()) + + flag.Parse() +}) diff --git a/benchmark/benchmark_test.go b/benchmark/benchmark_test.go index 77e533da..2491b123 100644 --- a/benchmark/benchmark_test.go +++ b/benchmark/benchmark_test.go @@ -13,78 +13,81 @@ import ( _ "github.com/lucas-clemente/quic-go/integrationtests/tools/testlog" "github.com/lucas-clemente/quic-go/internal/protocol" "github.com/lucas-clemente/quic-go/internal/testdata" + . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" ) -func init() { - var _ = Describe("Benchmarks", func() { - dataLen := size * /* MB */ 1e6 - data := make([]byte, dataLen) - rand.Seed(GinkgoRandomSeed()) - rand.Read(data) // no need to check for an error. math.Rand.Read never errors +var _ = Describe("Benchmarks", func() { + for i := range protocol.SupportedVersions { + version := protocol.SupportedVersions[i] - for i := range protocol.SupportedVersions { - version := protocol.SupportedVersions[i] + Context(fmt.Sprintf("with version %s", version), func() { + var data []byte + var dataLen int - Context(fmt.Sprintf("with version %s", version), func() { - Measure(fmt.Sprintf("transferring a %d MB file", size), func(b Benchmarker) { - var ln quic.Listener - serverAddr := make(chan net.Addr) - handshakeChan := make(chan struct{}) - // start the server - go func() { - defer GinkgoRecover() - var err error - tlsConf := testdata.GetTLSConfig() - tlsConf.NextProtos = []string{"benchmark"} - ln, err = quic.ListenAddr( - "localhost:0", - tlsConf, - &quic.Config{Versions: []protocol.VersionNumber{version}}, - ) - Expect(err).ToNot(HaveOccurred()) - serverAddr <- ln.Addr() - sess, err := ln.Accept(context.Background()) - Expect(err).ToNot(HaveOccurred()) - // wait for the client to complete the handshake before sending the data - // this should not be necessary, but due to timing issues on the CIs, this is necessary to avoid sending too many undecryptable packets - <-handshakeChan - str, err := sess.OpenStream() - Expect(err).ToNot(HaveOccurred()) - _, err = str.Write(data) - Expect(err).ToNot(HaveOccurred()) - err = str.Close() - Expect(err).ToNot(HaveOccurred()) - }() + BeforeEach(func() { + dataLen = size * /* MB */ 1e6 + data = make([]byte, dataLen) + rand.Read(data) // no need to check for an error. math.Rand.Read never errors + }) - // start the client - addr := <-serverAddr - sess, err := quic.DialAddr( - addr.String(), - &tls.Config{InsecureSkipVerify: true, NextProtos: []string{"benchmark"}}, + Measure("transferring a file", func(b Benchmarker) { + var ln quic.Listener + serverAddr := make(chan net.Addr) + handshakeChan := make(chan struct{}) + // start the server + go func() { + defer GinkgoRecover() + var err error + tlsConf := testdata.GetTLSConfig() + tlsConf.NextProtos = []string{"benchmark"} + ln, err = quic.ListenAddr( + "localhost:0", + tlsConf, &quic.Config{Versions: []protocol.VersionNumber{version}}, ) Expect(err).ToNot(HaveOccurred()) - close(handshakeChan) - str, err := sess.AcceptStream(context.Background()) + serverAddr <- ln.Addr() + sess, err := ln.Accept(context.Background()) Expect(err).ToNot(HaveOccurred()) + // wait for the client to complete the handshake before sending the data + // this should not be necessary, but due to timing issues on the CIs, this is necessary to avoid sending too many undecryptable packets + <-handshakeChan + str, err := sess.OpenStream() + Expect(err).ToNot(HaveOccurred()) + _, err = str.Write(data) + Expect(err).ToNot(HaveOccurred()) + err = str.Close() + Expect(err).ToNot(HaveOccurred()) + }() - buf := &bytes.Buffer{} - // measure the time it takes to download the dataLen bytes - // note we're measuring the time for the transfer, i.e. excluding the handshake - runtime := b.Time("transfer time", func() { - _, err := io.Copy(buf, str) - Expect(err).NotTo(HaveOccurred()) - }) - Expect(buf.Bytes()).To(Equal(data)) + // start the client + addr := <-serverAddr + sess, err := quic.DialAddr( + addr.String(), + &tls.Config{InsecureSkipVerify: true, NextProtos: []string{"benchmark"}}, + &quic.Config{Versions: []protocol.VersionNumber{version}}, + ) + Expect(err).ToNot(HaveOccurred()) + close(handshakeChan) + str, err := sess.AcceptStream(context.Background()) + Expect(err).ToNot(HaveOccurred()) - b.RecordValue("transfer rate [MB/s]", float64(dataLen)/1e6/runtime.Seconds()) + buf := &bytes.Buffer{} + // measure the time it takes to download the dataLen bytes + // note we're measuring the time for the transfer, i.e. excluding the handshake + runtime := b.Time("transfer time", func() { + _, err := io.Copy(buf, str) + Expect(err).NotTo(HaveOccurred()) + }) + Expect(buf.Bytes()).To(Equal(data)) - ln.Close() - sess.Close() - }, samples) - }) - } - }) -} + b.RecordValue("transfer rate [MB/s]", float64(dataLen)/1e6/runtime.Seconds()) + + ln.Close() + sess.Close() + }, 3) + }) + } +})