Comparing compression options in .NET

Compression can be a useful tool for reducing the size of data transmitted over a network or stored on disk. The .NET framework includes several classes that can be used to compress and decompress data, including the BrotliStream, GZipStream, DeflateStream, and ZLibStream classes. In this article, we will look at these classes and benchmark their performance when compressing and decompressing data. We will use both the Optimal and SmallestSize compression levels. Our test data for this benchmark will be a byte array containing the entire bible (3.9 megabytes).

Example Compression Benchmark Method

Here is an example of a benchmark method that measures the time and memory required to compress a byte array using the BrotliStream class:

[Benchmark]
public byte[] CompressBrotli()
{
    var compression = Compression == "Optimal" ? CompressionLevel.Optimal : CompressionLevel.SmallestSize;
    using var output = new MemoryStream();
    using var compressor = new BrotliStream(output, compression, true);
    compressor.Write(Data, 0, Data.Length);
    compressor.Close();
    return output.ToArray();
}

This method creates a MemoryStream called output to store the compressed data, and a BrotliStream called compressor that wraps the output stream and performs the compression. The Write method is used to write the contents of the Data array to the compressor stream, and the Close method is called to tell the stream that no more data will be written. Finally, the ToArray method of the output stream is used to return the compressed data as a byte array.

Benchmark Results for Compression

The following table shows the results of running the compression benchmark on an input data set with a size of 3952 kb:

BenchmarkDotNet=v0.12.1, OS=Windows 10.0.22621
Intel Core i7-8750H CPU 2.20GHz (Coffee Lake), 1 CPU, 12 logical and 6 physical cores
.NET Core SDK=7.0.101
  [Host]     : .NET Core 7.0.1 (CoreCLR 7.0.122.56804, CoreFX 7.0.122.56804), X64 RyuJIT
  DefaultJob : .NET Core 7.0.1 (CoreCLR 7.0.122.56804, CoreFX 7.0.122.56804), X64 RyuJIT

In terms of the compression achieved, these were the results:

The results of the compression benchmark show that the BrotliStream class was the fastest at compressing the data in the optimal mode. In this mode, the BrotliStream class was able to compress the data in 89.09 ms, while the GZipStream, DeflateStream, and ZLibStream classes took 138.35 ms, 138.54 ms, and 139.66 ms, respectively. The BrotliStream class also used the least amount of memory, with a maximum allocation of 4.99 MB.

However, when it comes to compressing the data in the smallest size mode, the BrotliStream class was significantly slower than the other classes, taking 7,709.19 ms compared to 374.81 ms for GZipStream, 376.52 ms for DeflateStream, and 377.37 ms for ZLibStream.

When it comes to the compression achieved, the BrotliStream class was able to compress the data in the optimal mode by 27.13 %, while the GZipStream, DeflateStream, and ZLibStream classes were able to compress the data by 29.63 %. In the smallest size mode, the BrotliStream class was able to compress the data by 21.96 %, while the GZipStream, DeflateStream, and ZLibStream classes were able to compress the data by 29.07 %.

Example Decompression Benchmark Method

Here is an example of a benchmark method that measures the time and memory required to decompress a byte array using the BrotliStream class:

[Benchmark]
public byte[] DecompressBrotli()
{
    using var input = new MemoryStream(Data);
    using var decompressor = new BrotliStream(input, CompressionMode.Decompress);
    using var output = new MemoryStream();
    decompressor.CopyTo(output);
    return output.ToArray();
}

This method creates a MemoryStream called input that wraps the Data array, and another MemoryStream called output to store the decompressed data. It also creates a BrotliStream called decompressor that wraps the input stream and performs the decompression. The CopyTo method is used to copy the contents of the decompressor stream to the output stream, and the ToArray method of the output stream is used to return the decompressed data as a byte array.

Benchmark Results for Decompression

The following table shows the results of running the decompression benchmark on the data compressed in the previous benchmark:

In these results, we can see that the BrotliStream class was the fastest at decompressing the data, taking an average of 12.73 ms to complete the task. The GZipStream, DeflateStream, and ZLibStream classes all had similar performance, taking an average of 13.11 ms, 12.81 ms, and 13.99 ms, respectively. The results were not materially different when decompressing the data in the smallest size mode.

Conclusion

Looking at the results, in terms of performance, there really isn’t any reason to use anything but Brotli. If we’re looking for the best bang for our buck, Brotli offers the best compression ratio and the fastest compression and decompression times in the Optimal compression level.

If we’re looking for the absolute smallest size, Brotli is still the best option in terms of the compression ratio, but it is significantly slower than the other compression algorithms. But here’s the thing, Brotli on Optimal is still both faster and offers better compression than the other compression algorithms are on SmallestSize. In other words, Brotli is the best option for compression in almost every scenario.

A word of caution, the results you might achieve will differ based on the data you are trying to compress so it might be worth testing the different compression algorithms to see which one works best for your data.

Source Code

https://github.com/snowfrogdev/CompressionBenchmarks