Function BenchmarkRing_Get_OneZoneLeaving

ring/ring_test.go:3794–3849

(b *testing.B)

}

func BenchmarkRing_Get_OneZoneLeaving(b *testing.B) {
	// This benchmark tests a pathological case in the ring. If an entire zone is "LEAVING", we'll have to
	// look at every instance in that zone, extending the replication set, to try to find one we can use for
	// our operation. Previous versions of the ring would examine every single token in an attempt to find a
	// usable host in the zone with all instances "LEAVING", resulting in poor performance.
	const (
		instances = 1200
		zones     = 4
	)

	for _, oneZoneLeaving := range []bool{true, false} {
		b.Run(fmt.Sprintf("one zone leaving = %t", oneZoneLeaving), func(b *testing.B) {
			ringDesc := &Desc{Ingesters: generateRingInstances(initTokenGenerator(b), instances, zones, numTokens)}

			if oneZoneLeaving {
				// Go through the last zone and set the instances as leaving.
				for id, inst := range ringDesc.Ingesters {
					if inst.Zone == "zone-2" {
						inst.State = LEAVING
						ringDesc.Ingesters[id] = inst
					}
				}
			}

			ring := newRingForTesting(Config{
				HeartbeatTimeout:     time.Hour,
				ZoneAwarenessEnabled: true,
				SubringCacheDisabled: true,
				ReplicationFactor:    zones,
			}, true)

			ring.setRingStateFromDesc(ringDesc, false, false, false)
			ring.strategy = NewIgnoreUnhealthyInstancesReplicationStrategy()

			buf, bufHosts, bufZones := MakeBuffersForGet()
			r := rand.New(rand.NewSource(time.Now().UnixNano()))

			expectedInstances := zones
			if oneZoneLeaving {
				expectedInstances = zones - 1
			}

			b.ResetTimer()
			b.ReportAllocs()
			for n := 0; n < b.N; n++ {
				set, err := ring.Get(r.Uint32(), Write, buf, bufHosts, bufZones)
				if err != nil {
					b.Fatal(err)
				}
				if actualInstances := len(set.Instances); actualInstances != expectedInstances {
					b.Fatalf("expected %d instances, got %d", expectedInstances, actualInstances)
				}
			}
		})
	}
}

func TestRing_Get_NoMemoryAllocations(t *testing.T) {