Function BenchmarkRing_Get

ring/ring_test.go:3737–3792

(b *testing.B)

}

func BenchmarkRing_Get(b *testing.B) {
	benchCases := map[string]struct {
		numInstances      int
		numZones          int
		replicationFactor int
	}{
		"with zone awareness": {
			numInstances:      99,
			numZones:          3,
			replicationFactor: 3,
		},
		"one excluded zone": {
			numInstances:      66,
			numZones:          2,
			replicationFactor: 3,
		},
		"without zone awareness": {
			numInstances:      3,
			numZones:          1,
			replicationFactor: 3,
		},
		"without zone awareness, not enough instances": {
			numInstances:      2,
			numZones:          1,
			replicationFactor: 3,
		},
	}

	for benchName, benchCase := range benchCases {
		// Initialise the ring.
		ringDesc := &Desc{Ingesters: generateRingInstances(initTokenGenerator(b), benchCase.numInstances, benchCase.numZones, numTokens)}
		ring := newRingForTesting(Config{
			HeartbeatTimeout:     time.Hour,
			ZoneAwarenessEnabled: benchCase.numZones > 1,
			SubringCacheDisabled: true,
			ReplicationFactor:    benchCase.replicationFactor,
		}, true)
		ring.setRingStateFromDesc(ringDesc, false, false, false)

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

		expectedInstances := min(benchCase.numInstances, benchCase.replicationFactor)
		if ring.cfg.ZoneAwarenessEnabled {
			expectedInstances = min(benchCase.numZones, benchCase.replicationFactor)
		}

		b.Run(benchName, func(b *testing.B) {
			for n := 0; n < b.N; n++ {
				set, err := ring.Get(r.Uint32(), Write, buf, bufHosts, bufZones)
				assert.NoError(b, err)
				assert.Equal(b, expectedInstances, len(set.Instances))
			}
		})
	}
}

func BenchmarkRing_Get_OneZoneLeaving(b *testing.B) {