What is ReadOnlySpan<T> in C# and how fast is it?

I already wrote an article about the fastest way of extracting substrings in C#. Now I want to investigate Span structures more. Recently, Microsoft released the .NET 8 platform which has several new extension methods for ReadOnlySpan<T>. So I want to compare the performance of MemoryExtensions methods with counterparts in string class.

Benchmark

All the benchmarks use a JSON-file with a string array of size 135 892 elements. Each array element represents the different permissions for different folders. Strings has the following template:

<permission> for Folder: \\server-name\path\to\folder\

For example:

DENY Permission for Folder: \\server-name\path\to\folder\

My employer won’t be happy if I share the file, so you should trust me that this file contains such data. :)

In this benchmark, we’ll consider the following 8 methods:

In the context of Span-based methods, we also take into account the “Span + Allocation” scenario, which involves string allocation using the ToString method where applicable. This scenario arises when Span-based methods are initially used, but the ultimate outcome includes the allocation of a string through the ToString method.

As usual, for benchmarking, I used the BenchmarkDotNet library. The whole code of the benchmark class can be found here.

Results

Contains

The benchmark assesses whether each string in the provided collection contains the backslash character.

StartsWith

The benchmark evaluates whether each string in the given collection starts with the specified substring.

IndexOf

The benchmark retrieves the index of the substring “Folder” within each string in the given collection.

Split

This benchmark, designed as a synthetic test, utilizes the Split method to determine the maximum number of substrings between separators in each string within the provided collection.

Replace

These benchmarks focus on replacing backslashes with forward slashes in each string within the provided collection, using different methods for string manipulation.

ToLowerInvariant

These benchmarks focus on converting each string within the provided collection to lowercase, utilizing different methods for case transformation.

Trim

These benchmarks focus on trimming trailing backslashes from the specified substring in each string within the provided collection, utilizing various approaches to achieve the desired result.

Substring

These benchmarks focus on extracting a substring between specific markers in each string within the provided collection, using different methods to achieve the desired substring extraction.

Conclusion

ReadOnlySpan<T> without allocation

As we can see from the figure above, almost all extension methods for ReadOnlySpan<T> are faster than analogues from string class. The only exception is the ReadOnlySpan<T>.ToLower method. I assume that It is because this method copies the characters from the source span into the destination.

ReadOnlySpan<T> with allocation

The string.Replace, string.ToLower, string.TrimEnd, string.Substring methods outperform the combination of ReadOnlySpan<T> methods and ReadOnlySpan<T>.ToString. This difference is likely due to efficient implementations of these methods. For example, invoking the string.TrimEnd leads to a call of the Buffer.Memmove method. It appears that the string allocation process using Buffer.Memmove is more efficient than the implementation of ReadOnlySpan<T>.ToString.

Memory consumption

Span-based methods exhibit superior memory efficiency, with zero memory allocations and no observed Gen 0 collections. String methods, particularly in operations like Split, Replace, and ToLower, tend to incur more significant memory allocations and, in some cases, Gen 0 collections. Therefore, for memory-conscious applications, utilizing Span-based methods may offer performance advantages in terms of reduced memory footprint and improved garbage collection behavior.

Notice almost the same or even worse results for the “Span + Allocation” column. Despite the utilization of Span-based methods in the intermediate steps, the inclusion of string allocation in the final outcome appears to negate some of the memory efficiency gained by using Span. This indicates that, in this specific context, the allocation of strings during or after Span-based operations may mitigate the potential memory benefits associated with using Span.

Generation 0 collections per 1000 operations

Memory allocated, Mb

Further reading

1. MemoryExtensions Class.
2. Spanification.
3. Pro .NET Memory Management.