Merge pull request #4536 from gofiber/claude/fiber-swar-optimization-iolg6j

perf: adopt SWAR-accelerated utils helpers in hot-path scanners

Author: ReneWerner87

binder/mapping.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/gofiber/utils/v2"
 	utilsstrings "github.com/gofiber/utils/v2/strings"
 	"github.com/valyala/bytebufferpool"
 
@@ -347,7 +348,7 @@ func equalFieldType(out any, kind reflect.Kind, key, aliasTag string) bool {
 
 // FilterFlags returns the media type value by trimming any parameters from a Content-Type header.
 func FilterFlags(content string) string {
-	if i := strings.IndexAny(content, " ;"); i >= 0 {
+	if i := utils.IndexAny2(content, ' ', ';'); i >= 0 {
 		return content[:i]
 	}
 	return content

constraint.go

@@ -10,6 +10,7 @@ import (
 	"time"
 	"unicode"
 
+	"github.com/gofiber/utils/v2/swar"
 	"github.com/google/uuid"
 )
 
@@ -252,8 +253,40 @@ type alphaConstraintType struct{}
 
 func (alphaConstraintType) Name() string { return ConstraintAlpha }
 func (alphaConstraintType) Execute(param string, _ []any) bool {
-	for _, c := range param {
-		if !unicode.IsLetter(c) {
+	// SWAR fast path for the ASCII-common case; the first word containing a
+	// non-ASCII byte defers the rest to the Unicode rune loop, and so does
+	// the sub-word tail. The handoff happens only where every preceding
+	// byte is ASCII, i.e. on a rune boundary.
+	n := len(param)
+	i := 0
+	for ; i+swar.WordLen <= n; i += swar.WordLen {
+		w := swar.Load8(param, i)
+		if w&swar.HighBits != 0 {
+			return isUnicodeAlpha(param[i:])
+		}
+		if swar.MatchRangeMask(w, 'A', 'Z')|swar.MatchRangeMask(w, 'a', 'z') != swar.HighBits {
+			return false
+		}
+	}
+	// Scalar tail rather than isUnicodeAlpha(param[i:]): short params are
+	// the common case and skipping the rune decoding measures ~12% faster
+	// on Benchmark_ConstraintExecution/alpha.
+	for ; i < n; i++ {
+		c := param[i]
+		if c >= 0x80 {
+			return isUnicodeAlpha(param[i:])
+		}
+		if lc := c | 0x20; lc < 'a' || lc > 'z' {
+			return false
+		}
+	}
+	return true
+}
+
+// isUnicodeAlpha reports whether s consists only of Unicode letters.
+func isUnicodeAlpha(s string) bool {
+	for _, r := range s {
+		if !unicode.IsLetter(r) {
 			return false
 		}
 	}
@@ -526,6 +559,8 @@ func (regexConstraintType) Execute(param string, data []any) bool {
 
 // resolveConstraintName handles case-insensitive and alias matching for constraint names.
 func resolveConstraintName(name string) string {
+	// strings.ToLower (not the ASCII-only utils variant) so aliases keep
+	// Unicode simple case folding, e.g. Turkish-locale "MİNLEN" -> "minlen".
 	switch strings.ToLower(name) {
 	case "minlen":
 		return ConstraintMinLen

constraint_test.go

@@ -133,6 +133,22 @@ func Test_ConstraintExecute_AlphaConstraint(t *testing.T) {
 	require.True(t, handler.Execute("hello", nil))
 	require.True(t, handler.Execute("", nil))
 	require.False(t, handler.Execute("hello123", nil))
+
+	// Word-at-a-time fast-path coverage: inputs of exactly one word, more
+	// than one word, and rejections at word and tail positions.
+	require.True(t, handler.Execute("abcdefgh", nil))
+	require.True(t, handler.Execute("AbCdEfGhIjKlMnOpQ", nil))
+	require.False(t, handler.Execute("abcdefg1", nil))
+	require.False(t, handler.Execute("abcdefghijklmnop9", nil))
+	require.False(t, handler.Execute("abcdefgh-jkl", nil))
+
+	// Unicode letters must still be accepted via the rune fallback,
+	// regardless of where the first non-ASCII byte sits.
+	require.True(t, handler.Execute("héllo", nil))
+	require.True(t, handler.Execute("abcdefghé", nil))
+	require.False(t, handler.Execute("héllo1", nil))
+	require.False(t, handler.Execute("abcdefghé1", nil))
+	require.False(t, handler.Execute(string([]byte{0xC3, 0x28}), nil)) // invalid UTF-8
 }
 
 func Test_ConstraintExecute_GuidConstraint(t *testing.T) {
@@ -327,3 +343,16 @@ func Test_CustomConstraintWrapper_ExecuteKeepsLegacyArgsWithAnalyzer(t *testing.
 	require.True(t, c.matchConstraint("admin"))
 	require.False(t, c.matchConstraint("guest"))
 }
+
+func Test_resolveConstraintName_UnicodeFolding(t *testing.T) {
+	t.Parallel()
+
+	// Aliases fold with full Unicode simple case mapping, so locale-style
+	// uppercase such as the Turkish dotted capital I still canonicalizes;
+	// switching to an ASCII-only fold silently drops these constraints.
+	require.Equal(t, ConstraintMinLen, resolveConstraintName("minLen"))
+	require.Equal(t, ConstraintMinLen, resolveConstraintName("MINLEN"))
+	require.Equal(t, ConstraintMinLen, resolveConstraintName("MİNLEN"))
+	require.Equal(t, ConstraintMaxLen, resolveConstraintName("MAXLEN"))
+	require.Equal(t, "unknown", resolveConstraintName("unknown"))
+}

ctx.go

@@ -18,7 +18,6 @@ import (
 	"time"
 
 	"github.com/gofiber/utils/v2"
-	utilsbytes "github.com/gofiber/utils/v2/bytes"
 	"github.com/valyala/bytebufferpool"
 	"github.com/valyala/fasthttp"
 )
@@ -692,10 +691,12 @@ func (c *DefaultCtx) configDependentPaths() {
 
 	// another path is specified which is for routing recognition only
 	// use the path that was changed by the previous configuration flags
-	// If CaseSensitive is disabled, we lowercase the original path
-	c.detectionPath = append(c.detectionPath[:0], c.path...)
+	// If CaseSensitive is disabled, we lowercase the original path while
+	// copying it, fusing the copy and the case fold into a single pass.
 	if !c.app.config.CaseSensitive {
-		utilsbytes.UnsafeToLower(c.detectionPath)
+		c.detectionPath = appendLowerASCII(c.detectionPath[:0], c.path)
+	} else {
+		c.detectionPath = append(c.detectionPath[:0], c.path...)
 	}
 	// If StrictRouting is disabled, we strip all trailing slashes
 	if !c.app.config.StrictRouting && len(c.detectionPath) > 1 && c.detectionPath[len(c.detectionPath)-1] == '/' {

extractors/extractors.go

@@ -551,6 +551,9 @@ func Chain(extractors ...Extractor) Extractor {
 }
 
 // isValidToken68 checks if a string is a valid token68 per RFC 7235/9110.
+// NOTE: a swar.MatchRangeMask-based rewrite of this scan benchmarked 16%
+// slower than this scalar loop (the six-mask character class costs more per
+// word than the compiler's optimized switch costs per byte), so it stays.
 func isValidToken68(token string) bool {
 	if token == "" {
 		return false

extractors/extractors_test.go

@@ -1066,6 +1066,13 @@ func Test_isValidToken68(t *testing.T) {
 		{token: "token68==", want: true, name: "multiple equals at end"},
 		{token: "token68=extra", want: false, name: "equals followed by extra chars"},
 		{token: "T0ken-._~+/=", want: true, name: "all allowed chars with equals at end"},
+		{token: "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9P", want: true, name: "jwt-like long token"},
+		{token: "abcdefgh", want: true, name: "8-byte token accepted"},
+		{token: "abcdefg,", want: false, name: "trailing comma rejected"},
+		{token: "abcdefghijklmno\x00", want: false, name: "NUL rejected"},
+		{token: "abcdefgh\xc3\xa9", want: false, name: "non-ascii rejected"},
+		{token: "abcdefghijklmnop====", want: true, name: "long token with padding run"},
+		{token: "abcdefghijklmnop==x=", want: false, name: "base char inside padding run"},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
@@ -1077,3 +1084,20 @@ func Test_isValidToken68(t *testing.T) {
 		})
 	}
 }
+
+// go test -v -run=^$ -bench=Benchmark_isValidToken68 -benchmem -count=4
+func Benchmark_isValidToken68(b *testing.B) {
+	inputs := []string{
+		"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9P", // JWT-like
+		"dXNlcjpwYXNzd29yZA==", // short base64 credential
+		"token@invalid",        // early reject
+	}
+	var got bool
+	b.ReportAllocs()
+	for b.Loop() {
+		for _, in := range inputs {
+			got = isValidToken68(in)
+		}
+	}
+	_ = got
+}

helpers.go

@@ -24,6 +24,7 @@ import (
 
 	"github.com/gofiber/utils/v2"
 	utilsbytes "github.com/gofiber/utils/v2/bytes"
+	"github.com/gofiber/utils/v2/swar"
 
 	"github.com/gofiber/fiber/v3/internal/contextvalue"
 	"github.com/gofiber/fiber/v3/log"
@@ -165,28 +166,65 @@ func readContent(rf io.ReaderFrom, name string) (int64, error) {
 	return n, nil
 }
 
-// quoteRawString escapes only characters that need quoting according to
-// https://www.rfc-editor.org/rfc/rfc9110#section-5.6.4 so the result may
-// contain non-ASCII bytes.
-func (*App) quoteRawString(raw string) string {
-	// Fast path: most values need no escaping at all; avoid the pooled
-	// buffer and the string allocation entirely.
-	needsEscaping := false
-	for i := 0; i < len(raw); i++ {
+// quoteEscapeMask marks the lanes of w holding bytes quoteRawString must
+// escape: '\\', '"', any C0 control (including HTAB), or DEL. Lanes >= 0x80
+// are never marked; non-ASCII bytes pass through verbatim. This is
+// utils.IndexNonQuotable's RFC 9110 set widened by HTAB, which the RFC
+// permits as qdtext but this function has always percent-encoded.
+func quoteEscapeMask(w uint64) uint64 {
+	return swar.MatchByteMask(w, '\\') | swar.MatchByteMask(w, '"') |
+		swar.MatchRangeMask(w, 0x00, 0x1f) | swar.MatchByteMask(w, 0x7f)
+}
+
+// indexQuoteEscape returns the index of the first byte quoteEscapeMask
+// matches, or -1 if raw needs no escaping. It scans eight bytes at a time,
+// finishing inputs of 8+ bytes with one overlapping word; shorter inputs
+// are checked byte-wise.
+func indexQuoteEscape(raw string) int {
+	n := len(raw)
+	i := 0
+	for ; i+swar.WordLen <= n; i += swar.WordLen {
+		if m := quoteEscapeMask(swar.Load8(raw, i)); m != 0 {
+			return i + swar.FirstLane(m)
+		}
+	}
+	if i == n {
+		return -1
+	}
+	if n >= swar.WordLen {
+		if m := quoteEscapeMask(swar.Load8(raw, n-swar.WordLen)); m != 0 {
+			return n - swar.WordLen + swar.FirstLane(m)
+		}
+		return -1
+	}
+	for ; i < n; i++ {
 		if c := raw[i]; c == '\\' || c == '"' || c < 0x20 || c == 0x7f {
-			needsEscaping = true
-			break
+			return i
 		}
 	}
-	if !needsEscaping {
+	return -1
+}
+
+// quoteRawString escapes the characters that need quoting inside an RFC 9110
+// quoted-string (https://www.rfc-editor.org/rfc/rfc9110#section-5.6.4), plus
+// HTAB, which the RFC permits as qdtext but this function has always
+// percent-encoded. The result may contain non-ASCII bytes.
+func (*App) quoteRawString(raw string) string {
+	// Fast path: most values need no escaping at all; avoid the pooled
+	// buffer and the string allocation entirely.
+	end := indexQuoteEscape(raw)
+	if end == -1 {
 		return raw
 	}
 
 	const hex = "0123456789ABCDEF"
 	bb := bytebufferpool.Get()
 	defer bytebufferpool.Put(bb)
 
-	for i := 0; i < len(raw); i++ {
+	// Every byte before end is quotable and tab-free, so it hits the
+	// verbatim case of the switch below; copy it in one append.
+	bb.B = append(bb.B, raw[:end]...)
+	for i := end; i < len(raw); i++ {
 		c := raw[i]
 		switch {
 		case c == '\\' || c == '"':
@@ -212,15 +250,36 @@ func (*App) quoteRawString(raw string) string {
 	return string(bb.B)
 }
 
-// isASCII reports whether the provided string contains only ASCII characters.
-// See: https://www.rfc-editor.org/rfc/rfc0020
-func (*App) isASCII(s string) bool {
-	for i := 0; i < len(s); i++ {
-		if s[i] > 127 {
-			return false
+// appendLowerASCII writes the ASCII-lowercased bytes of src into dst[:0],
+// growing dst as needed, in a single pass over src (instead of a copy
+// followed by an in-place case fold). Bytes outside 'A'..'Z', including
+// non-ASCII, are copied unchanged. src and dst must not overlap.
+func appendLowerASCII(dst, src []byte) []byte {
+	n := len(src)
+	// Amortized growth like append: every byte of dst[:n] is overwritten
+	// below, so the grown slice's contents don't matter.
+	dst = slices.Grow(dst[:0], n)[:n]
+	i := 0
+	for ; i+swar.WordLen <= n; i += swar.WordLen {
+		swar.Store8(dst, i, swar.ToLowerWord(swar.Load8(src, i)))
+	}
+	if i == n {
+		return dst
+	}
+	if n >= swar.WordLen {
+		// Finish with one overlapping word; the overlapped bytes are
+		// rewritten with the same values.
+		swar.Store8(dst, n-swar.WordLen, swar.ToLowerWord(swar.Load8(src, n-swar.WordLen)))
+		return dst
+	}
+	for ; i < n; i++ {
+		c := src[i]
+		if c-'A' <= 'Z'-'A' {
+			c |= 0x20
 		}
+		dst[i] = c
 	}
-	return true
+	return dst
 }
 
 // defaultString returns the value or a default value if it is set
@@ -611,27 +670,33 @@ func forEachMediaRange(header []byte, functor func([]byte)) {
 		n := 0
 		header = utils.TrimLeft(header, ' ')
 		quotes := 0
-		escaping := false
 
 		if hasDQuote {
 			// Complex case. We need to keep track of quotes and quoted-pairs (i.e.,  characters escaped with \ )
+			// Only ',', '"' and '\\' can change state, so jump between them
+			// instead of visiting every byte.
 		loop:
 			for n < len(header) {
+				i := utils.IndexAny3(header[n:], ',', '"', '\\')
+				if i == -1 {
+					n = len(header)
+					break
+				}
+				n += i
 				switch header[n] {
 				case ',':
 					if quotes%2 == 0 {
 						break loop
 					}
 				case '"':
-					if !escaping {
-						quotes++
-					}
-				case '\\':
-					if quotes%2 == 1 {
-						escaping = !escaping
+					quotes++
+				default: // '\\'
+					if quotes%2 == 1 && n+1 < len(header) {
+						// A quoted-pair escapes exactly the next byte
+						// (RFC 9110 §5.6.4); consume it so an escaped
+						// quote is not mistaken for a closing quote.
+						n++
 					}
-				default:
-					// all other characters are ignored
 				}
 				n++
 			}
@@ -904,22 +969,25 @@ func (app *App) isEtagStale(etag string, noneMatchBytes []byte) bool {
 
 	// Split the header on commas that sit outside DQUOTE-delimited opaque-tags:
 	// etagc permits "," inside the quoted tag (RFC 9110 §8.8.3), so `"v1,v2"`
-	// is a single entity tag, not two list elements.
+	// is a single entity tag, not two list elements. Only '"' and ','
+	// affect the split, so jump between them instead of visiting every byte.
 	start := 0
+	pos := 0
 	inQuotes := false
-	for i := range len(header) {
-		switch header[i] {
-		case '"':
+	for {
+		i := utils.IndexAny2(header[pos:], '"', ',')
+		if i == -1 {
+			break
+		}
+		i += pos
+		pos = i + 1
+		if header[i] == '"' {
 			inQuotes = !inQuotes
-		case ',':
-			if !inQuotes {
-				if matchEtag(utils.TrimSpace(header[start:i]), etag) {
-					return false
-				}
-				start = i + 1
+		} else if !inQuotes {
+			if matchEtag(utils.TrimSpace(header[start:i]), etag) {
+				return false
 			}
-		default:
-			// any other byte belongs to the current list element
+			start = i + 1
 		}
 	}