Use a map instead of string to dedupe/track allowed matchers (#13052)

Every time `matcher.String()` is called on a matcher, 1024 bytes are
reserved to build the string. We don't _need_ to do this, since
comparison by string is just a shorthand for comparison by name, type,
and value.

Relates to #11920

Author: chencs

pkg/ingester/lookupplan/matcher_reducer_planner.go

@@ -66,11 +66,23 @@ func buildOutMatchers(inMatchers []*labels.Matcher, allowedOutMatchers []*labels
 	outMatchers := make([]*labels.Matcher, 0, len(inMatchers))
 	dedupedMatchers, dropped := dedupeMatchers(inMatchers)
 
-	// allowedInResultSet's keys are strings of matchers which are returned from setReduceMatchers(),
-	// and its values track whether each matcher string is already represented in outMatchers.
-	allowedInResultSet := make(map[string]bool, len(allowedOutMatchers))
+	// allowedInResultSet maps the relevant values of matchers returned by setReduce.
+	// The innermost map value tracks whether that matcher is already represented in outMatchers.
+	// We do it this way instead of using the matcher string via m.String()
+	// to avoid unnecessary memory allocations when building the string.
+	allowedInResultSet := make(map[labels.MatchType]map[string]map[string]bool, 4)
 	for _, m := range allowedOutMatchers {
-		allowedInResultSet[m.String()] = false
+		if _, ok := allowedInResultSet[m.Type][m.Name]; ok {
+			allowedInResultSet[m.Type][m.Name][m.Value] = false
+			continue
+		}
+		val := map[string]bool{m.Value: false}
+		if _, ok := allowedInResultSet[m.Type]; ok {
+			allowedInResultSet[m.Type][m.Name] = val
+			continue
+		}
+		name := map[string]map[string]bool{m.Name: val}
+		allowedInResultSet[m.Type] = name
 	}
 	// If we have reached the last deduped input matcher and are still not returning any matchers,
 	// we should return at least one matcher. This can happen if all input matchers are wildcard matchers.
@@ -82,9 +94,9 @@ func buildOutMatchers(inMatchers []*labels.Matcher, allowedOutMatchers []*labels
 		// allowedOutMatchers is used to both keep track of all unique matchers (evidenced by existence in the map),
 		// and whether the matcher has already been seen and added to a set of output matchers (evidenced by the value in the map).
 		// We only want to add the matcher if it hasn't already been added to an output slice.
-		if alreadyInResultSet, allowed := allowedInResultSet[m.String()]; allowed && !alreadyInResultSet {
+		if alreadyInResultSet, allowed := allowedInResultSet[m.Type][m.Name][m.Value]; allowed && !alreadyInResultSet {
 			outMatchers = append(outMatchers, m)
-			allowedInResultSet[m.String()] = true
+			allowedInResultSet[m.Type][m.Name][m.Value] = true
 		} else {
 			dropped = append(dropped, m)
 		}
@@ -125,20 +137,34 @@ func setReduceMatchers(ms []*labels.Matcher) []*labels.Matcher {
 	return outMatchers
 }
 
-// dedupeMatchers dedupes matchers based on their matcher string.
+// dedupeMatchers dedupes matchers based on their type, name, and value.
 func dedupeMatchers(ms []*labels.Matcher) ([]*labels.Matcher, []*labels.Matcher) {
-	deduped := make(map[string]*labels.Matcher, len(ms))
+	deduped := make(map[labels.MatchType]map[string]map[string]*labels.Matcher, 4)
 	dropped := make([]*labels.Matcher, 0, 1)
 	for _, m := range ms {
-		if _, ok := deduped[m.String()]; !ok {
-			deduped[m.String()] = m
-		} else {
+		if _, ok := deduped[m.Type][m.Name][m.Value]; ok {
 			dropped = append(dropped, m)
+			continue
 		}
+		if _, ok := deduped[m.Type][m.Name]; ok {
+			deduped[m.Type][m.Name][m.Value] = m
+			continue
+		}
+		valPtr := map[string]*labels.Matcher{m.Value: m}
+		if _, ok := deduped[m.Type]; ok {
+			deduped[m.Type][m.Name] = valPtr
+			continue
+		}
+		name := map[string]map[string]*labels.Matcher{m.Name: valPtr}
+		deduped[m.Type] = name
 	}
 	outMatchers := make([]*labels.Matcher, 0, len(deduped))
-	for _, ptr := range deduped {
-		outMatchers = append(outMatchers, ptr)
+	for _, nameMap := range deduped {
+		for _, valMap := range nameMap {
+			for _, ptr := range valMap {
+				outMatchers = append(outMatchers, ptr)
+			}
+		}
 	}
 	return outMatchers, dropped
 }