Function normalizeWeights

balancer/ringhash/ring.go:139–172

normalizeWeights calculates the normalized weights for each endpoint in the given endpoints map. It returns a slice of endpointWithState structs, where each struct contains the picker for an endpoint and its corresponding weight. The function also returns the minimum weight among all endpoints. The

(endpoints *resolver.EndpointMap[*endpointState])

//
// Must be called with a non-empty endpoints map.
func normalizeWeights(endpoints *resolver.EndpointMap[*endpointState]) ([]endpointInfo, float64) {
	var weightSum uint32
	// Since attributes are explicitly ignored in the EndpointMap key, we need
	// to iterate over the values to get the weights.
	endpointVals := endpoints.Values()
	for _, epState := range endpointVals {
		weightSum += epState.weight
	}
	ret := make([]endpointInfo, 0, endpoints.Len())
	min := 1.0
	for _, epState := range endpointVals {
		// (*endpointState).weight is set to 1 if the weight attribute is not
		// found on the endpoint. And since this function is guaranteed to be
		// called with a non-empty endpoints map, weightSum is guaranteed to be
		// non-zero. So, we need not worry about divide by zero error here.
		nw := float64(epState.weight) / float64(weightSum)
		ret = append(ret, endpointInfo{
			hashKey:        epState.hashKey,
			scaledWeight:   nw,
			originalWeight: epState.weight,
		})
		min = math.Min(min, nw)
	}
	// Sort the endpoints to return consistent results.
	//
	// Note: this might not be necessary, but this makes sure the ring is
	// consistent as long as the endpoints are the same, for example, in cases
	// where an endpoint is added and then removed, the RPCs will still pick the
	// same old endpoint.
	sort.Slice(ret, func(i, j int) bool {
		return ret[i].hashKey < ret[j].hashKey
	})
	return ret, min
}

// pick does a binary search. It returns the item with smallest index i that
// r.items[i].hash >= h.