Performance Improvements in .NET 8

In this article, we are going to see performance improvement in .NET8

As per Microsoft team .NET8 going to be released in November 2023.

.NET 8 is the long-term support (LTS) release, which means it will be supported for three years. This makes .NET 8 a better choice for developers who need long-term stability and support for their applications.

👉 .Net8 New features | Difference between .Net7 and .Net8

.NET 8 includes a number of performance improvements, including:

Tiering and Dynamic PGO: Tiering and Dynamic PGO (profile-guided optimization) are new features that can improve the performance of managed code by up to 20%. Tiering compiles code to multiple machine code representations, each optimized for a different runtime scenario. Dynamic PGO uses profiling data to optimize code at runtime.

// This code will be compiled to multiple machine code representations,
// each optimized for a different runtime scenario.
public int Fibonacci(int n)
{
    if (n <= 1)
    {
        return n;
    }

    return Fibonacci(n - 1) + Fibonacci(n - 2);
}

// This code will use profiling data to optimize code at runtime.
public int Factorial(int n)
{
    if (n <= 1)
    {
        return 1;
    }

    return n * Factorial(n - 1);
}

Vectorization: Vectorization is a technique that allows the CPU to process multiple elements of an array in parallel. .NET 8 includes a number of vectorization improvements, including support for new vector types and new intrinsics.

// This code will be vectorized to process multiple elements of the array in parallel.
int[] sum = new int[100000];
for (int i = 0; i < sum.Length; i++)
{
    sum[i] = i + 1;
}

// This code will use intrinsics to process multiple elements of the array 
in parallel.
int[] sum2 = new int[100000];
for (int i = 0; i < sum2.Length; i++)
{
    sum2[i] = Vector.Add(new Vector(i), new Vector(1));
}

Branching: Branching is a common operation in code, but it can be expensive for the CPU to perform. .NET 8 includes a number of branching improvements, including support for conditional move instructions and new prediction algorithms.

// This code will use conditional move instructions to avoid branching.
int x = 10;
if (x > 5)
{
    x = x + 1;
}
else
{
    x = x - 1;
}

// This code will use prediction algorithms to predict which branch will 
be taken and prefetch the necessary instructions.
int y = 10;
if (y > 5)
{
    y = y + 1;
}
else
{
    y = y - 1;
}

Bounds Checking: Bounds checking is a safety feature that prevents programmers from accessing memory outside of the bounds of an array. However, bounds-checking can also be expensive. .NET 8 includes a number of bounds checking improvements, including support for eliding bounds checks for known-safe operations.

// This code will elide the bounds check because the operation is known to be safe.
int[] array = new int[10];
int value = array[5];

// This code will use a new bounds-checking algorithm that is more 
efficient for known-safe operations.
int[] array2 = new int[10];
int value2 = array2[5];

Constant Folding: Constant folding is a technique that optimizes code by replacing compile-time constants with their values. .NET 8 includes a number of constant folding improvements, including support for folding more complex expressions.

// This code will fold the constant expression and replace it with its value.
int sum = 1 + 2 + 3;

// This code will fold the more complex constant expression and
 replace it with its value.
int sum2 = (1 + 2) * 3;

Non-GC Heap: The .NET runtime uses a garbage collector to manage memory. However, the garbage collector can also be expensive. .NET 8 includes a new non-GC heap that can be used to allocate memory that does not need to be garbage collected.

// This code will allocate the object on the non-GC heap.
byte[] bytes = new byte[1024 * 1024];
using (UnmanagedMemory.Pin(bytes))
{
    // Use the bytes array.
}

Zeroing: .NET 8 includes a number of zeroing improvements, including support for zeroing memory in parallel and support for zeroing memory without allocating a new object.

// This code will zero the memory in parallel.
byte[] bytes = new byte[1024 * 1024];
Parallel.For(0, bytes.Length, (i) => bytes[i] = 0);

// This code will zero the memory without allocating a new object.
byte[] bytes2 = new byte[1024 * 1024];
using (UnmanagedMemory.Pin(bytes2))
{
    Unsafe.InitBlock(bytes2.Pointer, 0, bytes2.Length);
}

Value Types: .NET 8 includes a number of value type improvements, including support for larger value types and support for boxing and unboxing value types more efficiently.

// This code will use a larger value type.
struct Point
{
    public int X;
    public int Y;
}

// This code will box and unbox value types more efficiently.
Point point = new Point { X = 10, Y = 20 };
int x = point.X;

Casting: .NET 8 includes a number of casting improvements, including support for casting between value types and reference types more efficiently.

// This code will cast between value types and reference types more efficiently.
object obj = 10;
int value = (int)obj;

Peephole Optimizations: Peephole optimizations are small optimizations that can be performed on compiled code. .NET 8 includes a number of new peephole optimizations.

// This peephole optimization will combine two instructions into one.
int x = 10;
int y = 20;
int sum = x + y;

In addition to these general performance improvements, .NET 8 also includes a number of performance improvements for specific areas, such as:

UTF8: .NET 8 includes a number of UTF8 performance improvements, including support for decoding UTF8 strings in parallel and support for encoding UTF8 strings without allocating a new object.
ASCII: .NET 8 includes a number of ASCII performance improvements, including support for encoding and decoding ASCII strings more efficiently.
Base64: .NET 8 includes a number of Base64 performance improvements, including support for encoding and decoding Base64 strings more efficiently.
Hex: .NET 8 includes a number of Hex performance improvements, including support for encoding and decoding Hex strings more efficiently.
String Formatting: .NET 8 includes a number of string formatting performance improvements, including support for formatting strings in parallel and support for formatting strings without allocating a new object.
Spans: Spans are a new type in .NET 8 that provide a more efficient way to work with memory. .NET 8 includes a number of performance improvements for spans, including support for copying spans more efficiently and support for comparing spans more efficiently.
SearchValues: SearchValues is a new type in .NET 8 that provides a more efficient way to search for values in a collection. .NET 8 includes a number of performance improvements for SearchValues, including support for searching for values in parallel and support for searching for values without allocating a new object.
Regex: .NET 8 includes a number of Regex performance improvements, including support for compiling regular expressions more efficiently and support for executing regular expressions more efficiently.
Hashing: .NET 8 includes a number of hashing performance improvements, including support for calculating hash codes more efficiently and support for comparing hash codes more efficiently.
Initialization: .NET 8 includes a number of initialization performance improvements, including support for initializing objects more efficiently and support for initializing arrays more efficiently.
Analyzers: .NET 8 includes a number of new analyzers that can help you identify and fix performance problems in your code.