mirror of
https://github.com/refraction-networking/uquic.git
synced 2025-04-03 20:27:35 +03:00
a93e544c94
Session.Close() sends a transport-level error code. Applications should not be able to call this function, but use CloseWithError() instead.
92 lines
2.6 KiB
Go
92 lines
2.6 KiB
Go
package benchmark
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/tls"
|
|
"fmt"
|
|
"io"
|
|
"math/rand"
|
|
"net"
|
|
|
|
quic "github.com/lucas-clemente/quic-go"
|
|
"github.com/lucas-clemente/quic-go/internal/protocol"
|
|
"github.com/lucas-clemente/quic-go/internal/testdata"
|
|
|
|
. "github.com/onsi/ginkgo"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
var _ = Describe("Benchmarks", func() {
|
|
for i := range protocol.SupportedVersions {
|
|
version := protocol.SupportedVersions[i]
|
|
|
|
Context(fmt.Sprintf("with version %s", version), func() {
|
|
var data []byte
|
|
var dataLen int
|
|
|
|
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
|
|
})
|
|
|
|
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())
|
|
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())
|
|
}()
|
|
|
|
// 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())
|
|
|
|
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))
|
|
|
|
b.RecordValue("transfer rate [MB/s]", float64(dataLen)/1e6/runtime.Seconds())
|
|
|
|
ln.Close()
|
|
sess.CloseWithError(0, "")
|
|
}, 3)
|
|
})
|
|
}
|
|
})
|