Benchmark tests for transport encrypt/decrypt functions

Signed-off-by: Sergey Matveev <stargrave@stargrave.org>

diff --git a/makefile b/makefile
index 3dec45c65c5f51e90273fb55cddc21e4e6084325..77a12ad9728436b896dece08430d80a75fbdb80c 100644 (file)
--- a/makefile
+++ b/makefile
@@ -15,3 +15,6 @@ govpn-client: dependencies
 
 govpn-server: dependencies
        go build -ldflags "$(LDFLAGS)" govpn/cmd/govpn-server
+
+bench: dependencies
+       GOMAXPROC=2 go test -bench .

diff --git a/tap.go b/tap.go
index 4fee83a28c3ea920cb619da22a1a9ddc984d71e7..6b298f713861ec621183dd4f546d00f2fd7afe77 100644 (file)
--- a/tap.go
+++ b/tap.go
@@ -20,7 +20,6 @@ package govpn
 
 import (
        "io"
-       "log"
 
        "golang.org/x/crypto/poly1305"
 )
@@ -63,8 +62,6 @@ func NewTAP(ifaceName string) (*TAP, error) {
        return &tap, nil
 }
 
-func (t *TAP) Write(data []byte) {
-       if _, err := t.dev.Write(data); err != nil {
-               log.Println("Error writing to iface: ", err)
-       }
+func (t *TAP) Write(data []byte) (n int, err error) {
+       return t.dev.Write(data)
 }

diff --git a/transport.go b/transport.go
index f33730218ee7d8955a38a860ec8a7bedf9f1f552..2638243311f17eed8bed6744d85a6ad8ee129eb7 100644 (file)
--- a/transport.go
+++ b/transport.go
@@ -21,6 +21,7 @@ package govpn
 import (
        "crypto/subtle"
        "encoding/binary"
+       "io"
        "log"
        "net"
        "time"
@@ -227,7 +228,7 @@ func newPeer(addr *net.UDPAddr, id PeerId, nonce int, key *[KeySize]byte) *Peer
 // ConnListen'es synchronization channel used to tell him that he is
 // free to receive new packets. Authenticated and decrypted packets
 // will be written to the interface immediately (except heartbeat ones).
-func (p *Peer) UDPProcess(udpPkt []byte, tap *TAP, ready chan struct{}) bool {
+func (p *Peer) UDPProcess(udpPkt []byte, tap io.Writer, ready chan struct{}) bool {
        size := len(udpPkt)
        copy(p.buf[:KeySize], Emptiness)
        copy(p.tag[:], udpPkt[size-poly1305.TagSize:])
@@ -265,12 +266,16 @@ func (p *Peer) UDPProcess(udpPkt []byte, tap *TAP, ready chan struct{}) bool {
        return true
 }
 
+type WriteToer interface {
+       WriteTo([]byte, net.Addr) (int, error)
+}
+
 // Process incoming Ethernet packet.
 // ethPkt is received data, conn is our outgoing connection.
 // ready channel is TAPListen's synchronization channel used to tell him
 // that he is free to receive new packets. Encrypted and authenticated
 // packets will be sent to remote Peer side immediately.
-func (p *Peer) EthProcess(ethPkt []byte, conn *net.UDPConn, ready chan struct{}) {
+func (p *Peer) EthProcess(ethPkt []byte, conn WriteToer, ready chan struct{}) {
        now := time.Now()
        size := len(ethPkt)
        // If this heartbeat is necessary

diff --git a/transport_test.go b/transport_test.go
new file mode 100644 (file)
index 0000000..11fe2c9
--- /dev/null
+++ b/transport_test.go
@@ -0,0 +1,61 @@
+package govpn
+
+import (
+       "net"
+       "testing"
+)
+
+var (
+       peer       *Peer
+       plaintext  []byte
+       ready      chan struct{}
+       dummy      = &Dummy{}
+       ciphertext []byte
+       addr       *net.UDPAddr
+       peerId     *PeerId
+)
+
+func init() {
+       MTU = 1500
+       Noncediff = 100
+       addr, _ = net.ResolveUDPAddr("udp", "[::1]:1")
+       peerId = IDDecode("ffffffffffffffffffffffffffffffff")
+       peer = newPeer(addr, *peerId, 128, new([KeySize]byte))
+       plaintext = make([]byte, 789)
+       ready = make(chan struct{})
+       go func() {
+               for {
+                       <-ready
+               }
+       }()
+}
+
+type Dummy struct{}
+
+func (d *Dummy) WriteTo(b []byte, addr net.Addr) (int, error) {
+       ciphertext = b
+       return len(b), nil
+}
+
+func (d *Dummy) Write(p []byte) (n int, err error) {
+       return len(p), nil
+}
+
+func BenchmarkEnc(b *testing.B) {
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               peer.NonceOur = 128
+               peer.EthProcess(plaintext, dummy, ready)
+       }
+}
+
+func BenchmarkDec(b *testing.B) {
+       peer.EthProcess(plaintext, dummy, ready)
+       peer = newPeer(addr, *peerId, 128, new([KeySize]byte))
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               if !peer.UDPProcess(ciphertext, dummy, ready) {
+                       b.Fail()
+               }
+       }
+}