Optimize string matching (#6121)

* query: Add benchmark for string matching

* query: Optimize away allocations in string matching

Improves performance by ~4x or more.

```
$ benchstat old.txt new.txt
goos: darwin
goarch: arm64
pkg: github.com/parca-dev/parca/pkg/query
cpu: Apple M1 Max
                                               │   old.txt    │               new.txt                │
                                               │    sec/op    │    sec/op     vs base                │
StringMatching/equalFoldBytes-10                 58.745n ± 1%   2.923n ±  7%  -95.02% (p=0.000 n=10)
StringMatching/containsFoldBytes-10               69.07n ± 7%   18.68n ±  3%  -72.95% (p=0.000 n=10)
StringMatching/hasPrefixFoldBytes-10              62.72n ± 2%   10.06n ± 13%  -83.96% (p=0.000 n=10)
StringMatchingLongStrings/containsFoldBytes-10   203.30n ± 2%   55.16n ±  2%  -72.87% (p=0.000 n=10)
geomean                                           84.81n        13.19n        -84.44%
```

Author: brancz

pkg/query/columnquery.go

@@ -982,33 +982,92 @@ func matchesFrameFilter(r *profile.RecordReader, locationIndex, lineIndex int, f
 	return true
 }
 
+// toLower converts ASCII byte to lowercase without allocation.
+// Non-ASCII bytes are left unchanged.
+func toLower(b byte) byte {
+	if b >= 'A' && b <= 'Z' {
+		return b + ('a' - 'A')
+	}
+	return b
+}
+
+// equalFoldBytes performs case-insensitive comparison without allocation.
+func equalFoldBytes(s, t []byte) bool {
+	if len(s) != len(t) {
+		return false
+	}
+	for i := 0; i < len(s); i++ {
+		if toLower(s[i]) != toLower(t[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// containsFoldBytes performs case-insensitive contains check without allocation.
+func containsFoldBytes(s, substr []byte) bool {
+	if len(substr) == 0 {
+		return true
+	}
+	if len(substr) > len(s) {
+		return false
+	}
+
+	// Search for substring
+	for i := 0; i <= len(s)-len(substr); i++ {
+		// Check if substring matches at position i
+		match := true
+		for j := 0; j < len(substr); j++ {
+			if toLower(s[i+j]) != toLower(substr[j]) {
+				match = false
+				break
+			}
+		}
+		if match {
+			return true
+		}
+	}
+	return false
+}
+
+// hasPrefixFoldBytes performs case-insensitive prefix check without allocation.
+func hasPrefixFoldBytes(s, prefix []byte) bool {
+	if len(prefix) > len(s) {
+		return false
+	}
+	for i := 0; i < len(prefix); i++ {
+		if toLower(s[i]) != toLower(prefix[i]) {
+			return false
+		}
+	}
+	return true
+}
+
 // matchesStringCondition checks if a value matches a string condition.
 func matchesStringCondition(value []byte, condition *pb.StringCondition) bool {
 	if condition == nil {
 		return true
 	}
 
-	valueLower := bytes.ToLower(value)
-
 	switch condition.GetCondition().(type) {
 	case *pb.StringCondition_Equal:
-		target := bytes.ToLower([]byte(condition.GetEqual()))
-		return bytes.Equal(valueLower, target)
+		target := []byte(condition.GetEqual())
+		return equalFoldBytes(value, target)
 	case *pb.StringCondition_NotEqual:
-		target := bytes.ToLower([]byte(condition.GetNotEqual()))
-		return !bytes.Equal(valueLower, target)
+		target := []byte(condition.GetNotEqual())
+		return !equalFoldBytes(value, target)
 	case *pb.StringCondition_Contains:
-		target := bytes.ToLower([]byte(condition.GetContains()))
-		return bytes.Contains(valueLower, target)
+		target := []byte(condition.GetContains())
+		return containsFoldBytes(value, target)
 	case *pb.StringCondition_NotContains:
-		target := bytes.ToLower([]byte(condition.GetNotContains()))
-		return !bytes.Contains(valueLower, target)
+		target := []byte(condition.GetNotContains())
+		return !containsFoldBytes(value, target)
 	case *pb.StringCondition_StartsWith:
-		target := bytes.ToLower([]byte(condition.GetStartsWith()))
-		return bytes.HasPrefix(valueLower, target)
+		target := []byte(condition.GetStartsWith())
+		return hasPrefixFoldBytes(value, target)
 	case *pb.StringCondition_NotStartsWith:
-		target := bytes.ToLower([]byte(condition.GetNotStartsWith()))
-		return !bytes.HasPrefix(valueLower, target)
+		target := []byte(condition.GetNotStartsWith())
+		return !hasPrefixFoldBytes(value, target)
 	default:
 		return true
 	}

pkg/query/string_match_bench_test.go

@@ -0,0 +1,78 @@
+// Copyright 2022-2025 The Parca Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package query
+
+import (
+	"testing"
+
+	pb "github.com/parca-dev/parca/gen/proto/go/parca/query/v1alpha1"
+)
+
+func BenchmarkStringMatching(b *testing.B) {
+	testValue := []byte("runtime.goexit")
+	testTarget := []byte("goexit")
+
+	b.Run("equalFoldBytes", func(b *testing.B) {
+		condition := &pb.StringCondition{
+			Condition: &pb.StringCondition_Equal{
+				Equal: string(testTarget),
+			},
+		}
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_ = matchesStringCondition(testValue, condition)
+		}
+	})
+
+	b.Run("containsFoldBytes", func(b *testing.B) {
+		condition := &pb.StringCondition{
+			Condition: &pb.StringCondition_Contains{
+				Contains: string(testTarget),
+			},
+		}
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_ = matchesStringCondition(testValue, condition)
+		}
+	})
+
+	b.Run("hasPrefixFoldBytes", func(b *testing.B) {
+		condition := &pb.StringCondition{
+			Condition: &pb.StringCondition_StartsWith{
+				StartsWith: "runtime",
+			},
+		}
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_ = matchesStringCondition(testValue, condition)
+		}
+	})
+}
+
+func BenchmarkStringMatchingLongStrings(b *testing.B) {
+	testValue := []byte("github.com/parca-dev/parca/pkg/profilestore/profilestoreserver.(*ProfileStoreServer).WriteRaw")
+	testTarget := []byte("profilestore")
+
+	b.Run("containsFoldBytes", func(b *testing.B) {
+		condition := &pb.StringCondition{
+			Condition: &pb.StringCondition_Contains{
+				Contains: string(testTarget),
+			},
+		}
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_ = matchesStringCondition(testValue, condition)
+		}
+	})
+}