s2: Add Benchmarks for RegionCoverer.

Cap and Cell are ~O(1) on time and memory bytes and allocs.
CellUnions end up at ~O(n) on time, and ~O(1) on memory bytes and allocs.
Loops up to 256 edges are ~O(1) on time and memory bytes and allocs.
For Loops beyond ~256 edges, there is a massive jump in time, memory and
allocs and then moves to ~O(n log n).

BenchmarkRegionCovererCoveringLoop/Loop-4-edges-42         	   64058 18569 ns/op	    1904 B/op	      42 allocs/op
BenchmarkRegionCovererCoveringLoop/Loop-8-edges-42         	   53868 21499 ns/op	    1972 B/op	      44 allocs/op
BenchmarkRegionCovererCoveringLoop/Loop-32-edges-42        	   71096 19208 ns/op	    1900 B/op	      43 allocs/op
BenchmarkRegionCovererCoveringLoop/Loop-64-edges-42        	   67424 15791 ns/op	    2184 B/op	      45 allocs/op
BenchmarkRegionCovererCoveringLoop/Loop-128-edges-42       	   66159 18145 ns/op	    2847 B/op	      51 allocs/op
BenchmarkRegionCovererCoveringLoop/Loop-256-edges-42       	   43219 24792 ns/op	    5484 B/op	      71 allocs/op
BenchmarkRegionCovererCoveringLoop/Loop-512-edges-42       	    1048 986620 ns/op	  331277 B/op	    2555 allocs/op
BenchmarkRegionCovererCoveringLoop/Loop-1024-edges-42      	     747 1996238 ns/op	  723120 B/op	    5362 allocs/op
BenchmarkRegionCovererCoveringLoop/Loop-2048-edges-42      	     297 4358194 ns/op	 1869751 B/op	   10740 allocs/op
BenchmarkRegionCovererCoveringLoop/Loop-4096-edges-42      	     136 8244599 ns/op	 4250742 B/op	   21618 allocs/op

Signed-off-by: David Symonds <dsymonds@golang.org>

Author: rsned

s2/regioncoverer_test.go

@@ -15,6 +15,7 @@
 package s2
 
 import (
+	"fmt"
 	"math"
 	"math/rand"
 	"reflect"
@@ -193,6 +194,87 @@ func TestRegionCovererSimpleRegionCovering(t *testing.T) {
 	}
 }
 
+const numCoveringBMRegions = 1000
+
+func BenchmarkRegionCovererCoveringCap(b *testing.B) {
+	benchmarkRegionCovererCovering(b, func(n int) string {
+		return fmt.Sprintf("Cap%d", n)
+	},
+		func(n int) []Region {
+			regions := make([]Region, numCoveringBMRegions)
+			for i := 0; i < numCoveringBMRegions; i++ {
+				regions[i] = randomCap(0.1*AvgAreaMetric.Value(maxLevel), 4*math.Pi)
+			}
+			return regions
+		})
+}
+
+func BenchmarkRegionCovererCoveringCell(b *testing.B) {
+	benchmarkRegionCovererCovering(b, func(n int) string {
+		return fmt.Sprintf("Cell%d", n)
+	},
+		func(n int) []Region {
+			regions := make([]Region, numCoveringBMRegions)
+			for i := 0; i < numCoveringBMRegions; i++ {
+				regions[i] = CellFromCellID(randomCellIDForLevel(maxLevel - randomUniformInt(n)))
+			}
+			return regions
+		})
+}
+
+func BenchmarkRegionCovererCoveringLoop(b *testing.B) {
+	benchmarkRegionCovererCovering(b, func(n int) string {
+		return fmt.Sprintf("Loop-%d-edges", int(math.Pow(2.0, float64(n))))
+	},
+		func(n int) []Region {
+			size := int(math.Pow(2.0, float64(n)))
+			regions := make([]Region, numCoveringBMRegions)
+			for i := 0; i < numCoveringBMRegions; i++ {
+				regions[i] = RegularLoop(randomPoint(), kmToAngle(10.0), size)
+			}
+			return regions
+		})
+}
+
+func BenchmarkRegionCovererCoveringCellUnion(b *testing.B) {
+	benchmarkRegionCovererCovering(b, func(n int) string {
+		return fmt.Sprintf("CellUnion-%d-cells", int(math.Pow(2.0, float64(n))))
+	},
+		func(n int) []Region {
+			size := int(math.Pow(2.0, float64(n)))
+			regions := make([]Region, numCoveringBMRegions)
+			for i := 0; i < numCoveringBMRegions; i++ {
+				cu := randomCellUnion(size)
+				regions[i] = &cu
+			}
+			return regions
+		})
+}
+
+// TODO(roberts): Add more benchmarking that changes the values in the coverer (min/max level, # cells).
+
+// benchmark Covering using the supplied func to generate a slice of random Regions of
+// the given type to choose from for the benchmark.
+//
+// e.g. Loops with [4..~2^n] edges, CellUnions of 2^n random Cells, random Cells and Caps
+func benchmarkRegionCovererCovering(b *testing.B, genLabel func(n int) string, genRegions func(n int) []Region) {
+	rc := &RegionCoverer{MinLevel: 0, MaxLevel: 30, LevelMod: 1, MaxCells: 8}
+
+	// Range over a variety of region complexities.
+	for n := 2; n <= 16; n++ {
+		b.Run(genLabel(n),
+			func(b *testing.B) {
+				b.StopTimer()
+				regions := genRegions(n)
+				l := len(regions)
+				b.StartTimer()
+				for i := 0; i < b.N; i++ {
+					rc.Covering(regions[i%l])
+				}
+			})
+	}
+}
+
 // TODO(roberts): Differences from C++
 //  func TestRegionCovererAccuracy(t *testing.T) {
 //  func TestRegionCovererFastCoveringHugeFixedLevelCovering(t *testing.T) {