Add Vector512/Vector256 SIMD acceleration to UTF-8 utility functions #120628
+362
−6
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Co-authored-by: stephentoub <[email protected]>
Copilot
AI
changed the title
Copilot finished work on behalf of
stephentoub
October 11, 2025 17:58
This was referenced Oct 11, 2025
? |
stephentoub
requested review from
DeepakRajendrakumaran,
Ruihan-Yin and
Copilot
There was a problem hiding this comment.
Pull Request Overview
This PR adds Vector512 and Vector256 SIMD acceleration to UTF-8 utility functions, enhancing performance for string operations on systems with AVX2 and AVX-512 support. The implementation follows established patterns from existing Vector128 code and provides graceful fallback to smaller vector sizes or scalar operations.
Key changes include:
- New Vector512 and Vector256 helper functions for ASCII detection and case-insensitive comparison
- Enhanced entry points that prioritize larger vector sizes (Vector512 → Vector256 → Vector128 → Scalar)
- Accelerated implementations for string equality and prefix matching operations
Reviewed Changes
Copilot reviewed 2 out of 2 changed files in this pull request and generated 10 comments.
| File | Description |
|---|---|
src/libraries/System.Private.CoreLib/src/System/Text/Unicode/Utf8Utility.cs |
Added Vector512/Vector256 ASCII detection and case-insensitive comparison helper functions |
src/libraries/System.Private.CoreLib/src/System/Globalization/Ordinal.Utf8.cs |
Implemented Vector512/Vector256 accelerated string comparison and prefix matching with cascading fallback logic |
Comment on lines
+147
to
+157
| return EqualsIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use Vector128 path for trailing elements if possible | ||
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | ||
| { | ||
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use scalar path for trailing elements | ||
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); |
There was a problem hiding this comment.
The remaining length calculation is incorrect. It should pass the actual remaining lengths of each string, not the minimum remaining length for both strings. This could cause buffer overruns or incorrect comparisons when the strings have different lengths.
Suggested change
| return EqualsIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| } | |
| // Use Vector128 path for trailing elements if possible | |
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | |
| { | |
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| return EqualsIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref charA, i), (int)(lengthA - i), ref Unsafe.Add(ref charB, i), (int)(lengthB - i)); | |
| } | |
| // Use Vector128 path for trailing elements if possible | |
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | |
| { | |
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthA - i), ref Unsafe.Add(ref charB, i), (int)(lengthB - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthA - i), ref Unsafe.Add(ref charB, i), (int)(lengthB - i)); |
Copilot uses AI. Check for mistakes.
Comment on lines
+147
to
+157
| return EqualsIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use Vector128 path for trailing elements if possible | ||
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | ||
| { | ||
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use scalar path for trailing elements | ||
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); |
There was a problem hiding this comment.
The remaining length calculation is incorrect. It should pass the actual remaining lengths of each string, not the minimum remaining length for both strings. This could cause buffer overruns or incorrect comparisons when the strings have different lengths.
Suggested change
| return EqualsIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| } | |
| // Use Vector128 path for trailing elements if possible | |
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | |
| { | |
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| return EqualsIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref charA, i), (int)(lengthA - i), ref Unsafe.Add(ref charB, i), (int)(lengthB - i)); | |
| } | |
| // Use Vector128 path for trailing elements if possible | |
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | |
| { | |
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthA - i), ref Unsafe.Add(ref charB, i), (int)(lengthB - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthA - i), ref Unsafe.Add(ref charB, i), (int)(lengthB - i)); |
Copilot uses AI. Check for mistakes.
Comment on lines
+147
to
+157
| return EqualsIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use Vector128 path for trailing elements if possible | ||
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | ||
| { | ||
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use scalar path for trailing elements | ||
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); |
There was a problem hiding this comment.
The remaining length calculation is incorrect. It should pass the actual remaining lengths of each string, not the minimum remaining length for both strings. This could cause buffer overruns or incorrect comparisons when the strings have different lengths.
Suggested change
| return EqualsIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| } | |
| // Use Vector128 path for trailing elements if possible | |
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | |
| { | |
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| return EqualsIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref charA, i), (int)(lengthA - (int)i), ref Unsafe.Add(ref charB, i), (int)(lengthB - (int)i)); | |
| } | |
| // Use Vector128 path for trailing elements if possible | |
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | |
| { | |
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthA - (int)i), ref Unsafe.Add(ref charB, i), (int)(lengthB - (int)i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthA - (int)i), ref Unsafe.Add(ref charB, i), (int)(lengthB - (int)i)); |
Copilot uses AI. Check for mistakes.
Comment on lines
+215
to
+219
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use scalar path for trailing elements | ||
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); |
There was a problem hiding this comment.
The remaining length calculation is incorrect. It should pass the actual remaining lengths of each string, not the minimum remaining length for both strings. This could cause buffer overruns or incorrect comparisons when the strings have different lengths.
Suggested change
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthA - i), ref Unsafe.Add(ref charB, i), (int)(lengthB - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthA - i), ref Unsafe.Add(ref charB, i), (int)(lengthB - i)); |
Copilot uses AI. Check for mistakes.
Comment on lines
+215
to
+219
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use scalar path for trailing elements | ||
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); |
There was a problem hiding this comment.
The remaining length calculation is incorrect. It should pass the actual remaining lengths of each string, not the minimum remaining length for both strings. This could cause buffer overruns or incorrect comparisons when the strings have different lengths.
Suggested change
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i)); | |
| return EqualsIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref charA, i), (int)(lengthA - i), ref Unsafe.Add(ref charB, i), (int)(lengthB - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthA - i), ref Unsafe.Add(ref charB, i), (int)(lengthB - i)); |
Copilot uses AI. Check for mistakes.
Comment on lines
+597
to
+607
| return StartsWithIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use Vector128 path for trailing elements if possible | ||
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | ||
| { | ||
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use scalar path for trailing elements | ||
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); |
There was a problem hiding this comment.
The remaining length calculation is incorrect. It should pass the actual remaining lengths of each string, not the minimum remaining length for both strings. This could cause buffer overruns or incorrect comparisons when the strings have different lengths.
Suggested change
| return StartsWithIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | |
| } | |
| // Use Vector128 path for trailing elements if possible | |
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | |
| { | |
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | |
| return StartsWithIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref source, i), (int)(sourceLength - i), ref Unsafe.Add(ref prefix, i), (int)(prefixLength - i)); | |
| } | |
| // Use Vector128 path for trailing elements if possible | |
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | |
| { | |
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), (int)(sourceLength - i), ref Unsafe.Add(ref prefix, i), (int)(prefixLength - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(sourceLength - i), ref Unsafe.Add(ref prefix, i), (int)(prefixLength - i)); |
Copilot uses AI. Check for mistakes.
Comment on lines
+597
to
+607
| return StartsWithIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use Vector128 path for trailing elements if possible | ||
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | ||
| { | ||
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use scalar path for trailing elements | ||
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); |
There was a problem hiding this comment.
The remaining length calculation is incorrect. It should pass the actual remaining lengths of each string, not the minimum remaining length for both strings. This could cause buffer overruns or incorrect comparisons when the strings have different lengths.
Suggested change
| return StartsWithIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | |
| } | |
| // Use Vector128 path for trailing elements if possible | |
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | |
| { | |
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | |
| return StartsWithIgnoreCaseUtf8_Vector256(ref Unsafe.Add(ref source, i), sourceLength - (int)i, ref Unsafe.Add(ref prefix, i), prefixLength - (int)i); | |
| } | |
| // Use Vector128 path for trailing elements if possible | |
| if (Vector128.IsHardwareAccelerated && (lengthU - i) >= (nuint)Vector128<byte>.Count) | |
| { | |
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), sourceLength - (int)i, ref Unsafe.Add(ref prefix, i), prefixLength - (int)i); | |
| } | |
| // Use scalar path for trailing elements | |
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), sourceLength - (int)i, ref Unsafe.Add(ref prefix, i), prefixLength - (int)i); |
Copilot uses AI. Check for mistakes.
| } | ||
|
|
||
| // Use scalar path for trailing elements | ||
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); |
There was a problem hiding this comment.
The remaining length calculation is incorrect. It should pass the actual remaining lengths of each string, not the minimum remaining length for both strings. This could cause buffer overruns or incorrect comparisons when the strings have different lengths.
Suggested change
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | |
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(sourceLength - i), ref Unsafe.Add(ref prefix, i), (int)(prefixLength - i)); |
Copilot uses AI. Check for mistakes.
Comment on lines
+665
to
+669
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use scalar path for trailing elements | ||
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); |
There was a problem hiding this comment.
The remaining length calculation is incorrect. It should pass the actual remaining lengths of each string, not the minimum remaining length for both strings. This could cause buffer overruns or incorrect comparisons when the strings have different lengths.
Suggested change
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | |
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), (int)(sourceLength - i), ref Unsafe.Add(ref prefix, i), (int)(prefixLength - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(sourceLength - i), ref Unsafe.Add(ref prefix, i), (int)(prefixLength - i)); |
Copilot uses AI. Check for mistakes.
Comment on lines
+665
to
+669
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | ||
| } | ||
|
|
||
| // Use scalar path for trailing elements | ||
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); |
There was a problem hiding this comment.
The remaining length calculation is incorrect. It should pass the actual remaining lengths of each string, not the minimum remaining length for both strings. This could cause buffer overruns or incorrect comparisons when the strings have different lengths.
Suggested change
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i)); | |
| return StartsWithIgnoreCaseUtf8_Vector128(ref Unsafe.Add(ref source, i), (int)(sourceLength - i), ref Unsafe.Add(ref prefix, i), (int)(prefixLength - i)); | |
| } | |
| // Use scalar path for trailing elements | |
| return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(sourceLength - i), ref Unsafe.Add(ref prefix, i), (int)(prefixLength - i)); |
Copilot uses AI. Check for mistakes.
|
What's the public API that this change is expected to materially improve? We need micro-benchmarks for it. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
4 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Summary
This PR adds Vector512 and Vector256 SIMD code paths to UTF-8 utility functions, providing significant performance improvements for string operations on systems with AVX2 and AVX-512 support.
Fixes #110940
Changes
New Vector Helper Functions (Utf8Utility.cs)
Extended existing Vector128-only functions to support larger vector sizes:
AllBytesInVector256AreAscii/AllBytesInVector512AreAscii- Efficiently check if 32/64 bytes are ASCIIVector256OrdinalIgnoreCaseAscii/Vector512OrdinalIgnoreCaseAscii- Perform case-insensitive comparison of 32/64 ASCII bytesUpdated String Comparison Functions (Ordinal.Utf8.cs)
Implemented Vector512/Vector256 fast paths with graceful fallback:
EqualsIgnoreCaseUtf8_Vector512/EqualsIgnoreCaseUtf8_Vector256- Accelerated equality comparison for OrdinalIgnoreCaseStartsWithIgnoreCaseUtf8_Vector512/StartsWithIgnoreCaseUtf8_Vector256- Accelerated prefix matching for OrdinalIgnoreCasePerformance Impact
These changes accelerate common string operations:
StringComparer.OrdinalIgnoreCasePerformance improvements scale with vector size:
Testing
All existing tests pass successfully:
Notes
Per the original issue, GetPointerToFirstInvalidChar in Utf16Utility.Validation.cs is intentionally not modified due to known performance issues with Vector512 execution unit contention (VPADDUSW vs VPMOVB2M).
Functions GetPointerToFirstInvalidByte and TranscodeToUtf8 already benefit from Vector512 acceleration through their use of
Ascii.GetIndexOfFirstNonAsciiByteandAscii.NarrowUtf16ToAsciifor ASCII fast paths. The complex multi-byte validation/transcoding logic would require extensive rework for further vectorization.Related Work
This implementation follows the established patterns in
Ascii.Utility.cswhich already includes Vector512 support, ensuring consistency across the codebase.Original prompt
Fixes #86119
💬 Share your feedback on Copilot coding agent for the chance to win a $200 gift card! Click here to start the survey.