increase benchmark coverage; introduce config struct.

* benchmark caching and cacheless variants of DS addrbook.
* benchmark peers with 1, 10, 100 addrs.

test/benchmarks_suite.go

@@ -0,0 +1,52 @@
+package test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+)
+
+var peerstoreBenchmarks = map[string]func(pstore.Peerstore, chan *peerpair) func(*testing.B){
+	"AddAddr":  benchmarkAddAddr,
+	"AddAddrs": benchmarkAddAddrs,
+	"SetAddrs": benchmarkSetAddrs,
+	"GetAddrs": benchmarkGetAddrs,
+}
+
+func BenchmarkPeerstore(b *testing.B, factory PeerstoreFactory, variant string) {
+	// Parameterises benchmarks to tackle peers with 1, 10, 100 multiaddrs.
+	params := []struct {
+		n  int
+		ch chan *peerpair
+	}{
+		{1, make(chan *peerpair, 100)},
+		{10, make(chan *peerpair, 100)},
+		{100, make(chan *peerpair, 100)},
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Start all test peer producing goroutines, where each produces peers with as many
+	// multiaddrs as the n field in the param struct.
+	for _, p := range params {
+		go addressProducer(ctx, b, p.ch, p.n)
+	}
+
+	for name, bench := range peerstoreBenchmarks {
+		for _, p := range params {
+			// Create a new peerstore.
+			ps, closeFunc := factory()
+
+			// Run the test.
+			b.Run(fmt.Sprintf("%s-%dAddrs-%s", name, p.n, variant), bench(ps, p.ch))
+
+			// Cleanup.
+			if closeFunc != nil {
+				closeFunc()
+			}
+		}
+	}
+}

test/peerstore_suite.go

@@ -15,7 +15,7 @@ import (
 	pstore "github.com/libp2p/go-libp2p-peerstore"
 )
 
-var peerstoreSuite = map[string]func(book pstore.Peerstore) func(*testing.T){
+var peerstoreSuite = map[string]func(pstore.Peerstore) func(*testing.T){
 	"AddrStream":               testAddrStream,
 	"GetStreamBeforePeerAdded": testGetStreamBeforePeerAdded,
 	"AddStreamDuplicates":      testAddrStreamDuplicates,
@@ -40,16 +40,6 @@ func TestPeerstore(t *testing.T, factory PeerstoreFactory) {
 	}
 }
 
-func BenchmarkPeerstore(b *testing.B, factory PeerstoreFactory) {
-	ps, closeFunc := factory()
-
-	b.Run("Peerstore", benchmarkPeerstore(ps))
-
-	if closeFunc != nil {
-		closeFunc()
-	}
-}
-
 func testAddrStream(ps pstore.Peerstore) func(t *testing.T) {
 	return func(t *testing.T) {
 		addrs, pid := getAddrs(t, 100), peer.ID("testpeer")
@@ -289,19 +279,45 @@ func testBasicPeerstore(ps pstore.Peerstore) func(t *testing.T) {
 	}
 }
 
-func benchmarkPeerstore(ps pstore.Peerstore) func(*testing.B) {
+func benchmarkAddAddr(ps pstore.Peerstore, addrs chan *peerpair) func(*testing.B) {
 	return func(b *testing.B) {
-		addrs := make(chan *peerpair, 100)
-
-		ctx, cancel := context.WithCancel(context.Background())
-		go addressProducer(ctx, b, addrs)
-
 		b.ResetTimer()
 		for i := 0; i < b.N; i++ {
 			pp := <-addrs
-			ps.AddAddr(pp.ID, pp.Addr, pstore.PermanentAddrTTL)
+			ps.AddAddr(pp.ID, pp.Addr[0], pstore.PermanentAddrTTL)
+		}
+	}
+}
+
+func benchmarkAddAddrs(ps pstore.Peerstore, addrs chan *peerpair) func(*testing.B) {
+	return func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			pp := <-addrs
+			ps.AddAddrs(pp.ID, pp.Addr, pstore.PermanentAddrTTL)
+		}
+	}
+}
+
+func benchmarkSetAddrs(ps pstore.Peerstore, addrs chan *peerpair) func(*testing.B) {
+	return func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			pp := <-addrs
+			ps.SetAddrs(pp.ID, pp.Addr, pstore.PermanentAddrTTL)
+		}
+	}
+}
+
+func benchmarkGetAddrs(ps pstore.Peerstore, addrs chan *peerpair) func(*testing.B) {
+	return func(b *testing.B) {
+		pp := <-addrs
+		ps.SetAddrs(pp.ID, pp.Addr, pstore.PermanentAddrTTL)
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_ = ps.Addrs(pp.ID)
 		}
-		cancel()
 	}
 }
 

test/utils.go

@@ -28,33 +28,39 @@ func multiaddr(m string) ma.Multiaddr {
 
 type peerpair struct {
 	ID   peer.ID
-	Addr ma.Multiaddr
+	Addr []ma.Multiaddr
 }
 
-func randomPeer(b *testing.B) *peerpair {
-	var pid peer.ID
-	var err error
-	var addr ma.Multiaddr
+func randomPeer(b *testing.B, addrCount int) *peerpair {
+	var (
+		pid   peer.ID
+		err   error
+		addrs = make([]ma.Multiaddr, addrCount)
+		aFmt  = "/ip4/127.0.0.1/tcp/%d/ipfs/%s"
+	)
 
+	b.Helper()
 	if pid, err = pt.RandPeerID(); err != nil {
 		b.Fatal(err)
 	}
 
-	if addr, err = ma.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/tcp/6666/ipfs/%s", pid.Pretty())); err != nil {
-		b.Fatal(err)
+	for i := 0; i < addrCount; i++ {
+		if addrs[i], err = ma.NewMultiaddr(fmt.Sprintf(aFmt, i, pid.Pretty())); err != nil {
+			b.Fatal(err)
+		}
 	}
-
-	return &peerpair{pid, addr}
+	return &peerpair{pid, addrs}
 }
 
-func addressProducer(ctx context.Context, b *testing.B, addrs chan *peerpair) {
+func addressProducer(ctx context.Context, b *testing.B, addrs chan *peerpair, addrsPerPeer int) {
+	b.Helper()
 	defer close(addrs)
 	for {
-		p := randomPeer(b)
+		p := randomPeer(b, addrsPerPeer)
 		select {
 		case addrs <- p:
 		case <-ctx.Done():
 			return
 		}
 	}
-}
+}