fix(benchmarks): actually test providing

Author: hannahhoward

benchmarks_test.go

@@ -25,6 +25,8 @@ import (
 	mockrouting "github.com/ipfs/go-ipfs-routing/mock"
 )
 
+type topologyFunc func(b *testing.B, instances []testinstance.Instance)
+
 type fetchFunc func(b *testing.B, bs *bitswap.Bitswap, ks []cid.Cid)
 
 type distFunc func(b *testing.B, provs []testinstance.Instance, blocks []blocks.Block)
@@ -171,14 +173,14 @@ func BenchmarkDupsManyNodesRealWorldNetworkWithRealDHT(b *testing.B) {
 	slowNetworkDelay := delay.Delay(fastSpeed, slowNetworkDelayGenerator)
 	slowBandwidthGenerator := tn.VariableRateLimitGenerator(slowBandwidth, slowBandwidthDeviation, nil)
 
-	b.Run("10Nodes-AllToAll-BigBatch-FastNetwork", func(b *testing.B) {
-		subtestDistributeAndFetchWithRealDHT(b, 20, 10, fastNetworkDelay, fastBandwidthGenerator, stdBlockSize, allToAll, batchFetchAll)
+	b.Run("10Nodes-RandomRandom-BigBatch-FastNetwork", func(b *testing.B) {
+		subtestDistributeAndFetchWithRealDHT(b, 20, 10, fastNetworkDelay, fastBandwidthGenerator, stdBlockSize, starPattern, randomRandom, batchFetchAll)
 	})
-	b.Run("10Nodes-AllToAll-BigBatch-AverageVariableSpeedNetwork", func(b *testing.B) {
-		subtestDistributeAndFetchWithRealDHT(b, 20, 10, averageNetworkDelay, averageBandwidthGenerator, stdBlockSize, allToAll, batchFetchAll)
+	b.Run("10Nodes-RandomRandom-BigBatch-AverageVariableSpeedNetwork", func(b *testing.B) {
+		subtestDistributeAndFetchWithRealDHT(b, 20, 10, averageNetworkDelay, averageBandwidthGenerator, stdBlockSize, starPattern, randomRandom, batchFetchAll)
 	})
-	b.Run("10Nodes-AllToAll-BigBatch-SlowVariableSpeedNetwork", func(b *testing.B) {
-		subtestDistributeAndFetchWithRealDHT(b, 20, 10, slowNetworkDelay, slowBandwidthGenerator, stdBlockSize, allToAll, batchFetchAll)
+	b.Run("10Nodes-RandomRandom-BigBatch-SlowVariableSpeedNetwork", func(b *testing.B) {
+		subtestDistributeAndFetchWithRealDHT(b, 20, 10, slowNetworkDelay, slowBandwidthGenerator, stdBlockSize, starPattern, randomRandom, batchFetchAll)
 	})
 	out, _ := json.MarshalIndent(benchmarkLog, "", "  ")
 	ioutil.WriteFile("tmp/rw-benchmark.json", out, 0666)
@@ -189,7 +191,7 @@ func subtestDistributeAndFetch(b *testing.B, numnodes, numblks int, d delay.D, d
 		start := time.Now()
 		net := tn.VirtualNetwork(mockrouting.NewServer(), d)
 
-		ig := testinstance.NewTestInstanceGenerator(net)
+		ig := testinstance.NewTestInstanceGenerator(net, bitswap.ProvideEnabled(false))
 		defer ig.Close()
 
 		bg := blocksutil.NewBlockGenerator()
@@ -206,7 +208,7 @@ func subtestDistributeAndFetchRateLimited(b *testing.B, numnodes, numblks int, d
 		start := time.Now()
 		net := tn.RateLimitedVirtualNetwork(mockrouting.NewServer(), d, rateLimitGenerator)
 
-		ig := testinstance.NewTestInstanceGenerator(net)
+		ig := testinstance.NewTestInstanceGenerator(net, bitswap.ProvideEnabled(false))
 		defer ig.Close()
 
 		instances := ig.Instances(numnodes)
@@ -216,7 +218,7 @@ func subtestDistributeAndFetchRateLimited(b *testing.B, numnodes, numblks int, d
 	}
 }
 
-func subtestDistributeAndFetchWithRealDHT(b *testing.B, numnodes, numblks int, d delay.D, rateLimitGenerator tn.RateLimitGenerator, blockSize int64, df distFunc, ff fetchFunc) {
+func subtestDistributeAndFetchWithRealDHT(b *testing.B, numnodes, numblks int, d delay.D, rateLimitGenerator tn.RateLimitGenerator, blockSize int64, tf topologyFunc, df distFunc, ff fetchFunc) {
 	start := time.Now()
 	ctx := context.Background()
 	mn := mocknet.New(ctx)
@@ -236,8 +238,6 @@ func subtestDistributeAndFetchWithRealDHT(b *testing.B, numnodes, numblks int, d
 	}
 	mn.LinkAll()
 	for i, inst := range instances {
-		// Connect in a star pattern to first node only (like a bootstrap)
-		inst.Adapter.ConnectTo(context.Background(), instances[0].Peer)
 		// rate limit and delate connections
 		for j := i + 1; j < len(instances); j++ {
 			oinst := instances[j]
@@ -248,6 +248,8 @@ func subtestDistributeAndFetchWithRealDHT(b *testing.B, numnodes, numblks int, d
 		}
 	}
 
+	tf(b, instances)
+
 	blocks := testutil.GenerateBlocksOfSize(numblks, blockSize)
 
 	runDistribution(b, instances, blocks, df, ff, start)
@@ -285,13 +287,25 @@ func runDistribution(b *testing.B, instances []testinstance.Instance, blocks []b
 	b.Logf("send/recv: %d / %d", nst.MessagesSent, nst.MessagesRecvd)
 }
 
-func allToAll(b *testing.B, provs []testinstance.Instance, blocks []blocks.Block) {
-	for _, p := range provs {
-		if err := p.Blockstore().PutMany(blocks); err != nil {
+func starPattern(b *testing.B, instances []testinstance.Instance) {
+	for _, inst := range instances {
+		// Connect in a star pattern to first node only (like a bootstrap)
+		inst.Adapter.ConnectTo(context.Background(), instances[0].Peer)
+	}
+}
+
+func putMany(b *testing.B, p testinstance.Instance, blocks []blocks.Block) {
+	for _, blk := range blocks {
+		if err := p.Exchange.HasBlock(blk); err != nil {
 			b.Fatal(err)
 		}
 	}
 }
+func allToAll(b *testing.B, provs []testinstance.Instance, blocks []blocks.Block) {
+	for _, p := range provs {
+		putMany(b, p, blocks)
+	}
+}
 
 // overlap1 gives the first 75 blocks to the first peer, and the last 75 blocks
 // to the second peer. This means both peers have the middle 50 blocks
@@ -302,12 +316,8 @@ func overlap1(b *testing.B, provs []testinstance.Instance, blks []blocks.Block)
 	bill := provs[0]
 	jeff := provs[1]
 
-	if err := bill.Blockstore().PutMany(blks[:75]); err != nil {
-		b.Fatal(err)
-	}
-	if err := jeff.Blockstore().PutMany(blks[25:]); err != nil {
-		b.Fatal(err)
-	}
+	putMany(b, bill, blks[:75])
+	putMany(b, jeff, blks[25:])
 }
 
 // overlap2 gives every even numbered block to the first peer, odd numbered
@@ -319,16 +329,16 @@ func overlap2(b *testing.B, provs []testinstance.Instance, blks []blocks.Block)
 	bill := provs[0]
 	jeff := provs[1]
 
-	bill.Blockstore().Put(blks[0])
-	jeff.Blockstore().Put(blks[0])
+	bill.Exchange.HasBlock(blks[0])
+	jeff.Exchange.HasBlock(blks[0])
 	for i, blk := range blks {
 		if i%3 == 0 {
-			bill.Blockstore().Put(blk)
-			jeff.Blockstore().Put(blk)
+			bill.Exchange.HasBlock(blk)
+			jeff.Exchange.HasBlock(blk)
 		} else if i%2 == 1 {
-			bill.Blockstore().Put(blk)
+			bill.Exchange.HasBlock(blk)
 		} else {
-			jeff.Blockstore().Put(blk)
+			jeff.Exchange.HasBlock(blk)
 		}
 	}
 }
@@ -341,16 +351,16 @@ func overlap3(b *testing.B, provs []testinstance.Instance, blks []blocks.Block)
 	bill := provs[0]
 	jeff := provs[1]
 
-	bill.Blockstore().Put(blks[0])
-	jeff.Blockstore().Put(blks[0])
+	bill.Exchange.HasBlock(blks[0])
+	jeff.Exchange.HasBlock(blks[0])
 	for i, blk := range blks {
 		if i%3 == 0 {
-			bill.Blockstore().Put(blk)
-			jeff.Blockstore().Put(blk)
+			bill.Exchange.HasBlock(blk)
+			jeff.Exchange.HasBlock(blk)
 		} else if i%2 == 1 {
-			bill.Blockstore().Put(blk)
+			bill.Exchange.HasBlock(blk)
 		} else {
-			jeff.Blockstore().Put(blk)
+			jeff.Exchange.HasBlock(blk)
 		}
 	}
 }
@@ -360,7 +370,18 @@ func overlap3(b *testing.B, provs []testinstance.Instance, blks []blocks.Block)
 // but we're mostly just testing performance of the sync algorithm
 func onePeerPerBlock(b *testing.B, provs []testinstance.Instance, blks []blocks.Block) {
 	for _, blk := range blks {
-		provs[rand.Intn(len(provs))].Blockstore().Put(blk)
+		provs[rand.Intn(len(provs))].Exchange.HasBlock(blk)
+	}
+}
+
+// randomRandom distributes each block randomly -- to random peers a random amount of times
+func randomRandom(b *testing.B, provs []testinstance.Instance, blks []blocks.Block) {
+	for _, blk := range blks {
+		dups := rand.Intn(len(provs)) + 1
+		perm := rand.Perm(len(provs))
+		for i := 0; i < dups; i++ {
+			provs[perm[i]].Exchange.HasBlock(blk)
+		}
 	}
 }