.NET Serialization Performance Comparison

After reading the blog post from James Newton-King on serialization speed of the the new release of Jason.Net, I decided to benchmark the different serializers I have in my Disk Bases Data Structures project. The serialization is done to a byte array. (The project contains a factory class which benchmarks your data type and returns the fastest one)

AltSerialize can be found at codeproject, and the .Net implementations of Google Protocol Buffers at Google Code.

For the first test I used the same class hierarchy as Jason.Net.

The serialization sizes were as follow:

BinaryFormatter	2937 bytes
AltSerialize	610 bytes
DataContractSerializer	1237 bytes
protobuf-net	245

The second test is done on a well defined struct located at the bottom of this posting.

The serialization sizes were as follow:

BinaryFormatter	303 bytes
DataContractSerializer	272 bytes
AltSerialize	150 bytes
Marshal.Copy	144
Unsafe pointers	144

As you can see the memory copying variants are a lot faster than the other serializers when it comes to structs laid out sequential in memory. AltSerialize is also fairly quick, as it uses Marshal.Copy as well. The big winner is the version using pointers to copy the data. It’s 10x to Marshal.Copy on serialization and 17x on deserialization. Compared to the DataContractSerializer we’re talking almost 100x on serializing and over 250x on deserializing.

But remember that these tests were done on 100,000 iterations. For all normal purposes they would all work just fine.

If speed is of importance to you combined with a lot of serializing happening, then you can gain speed by choosing the right serializer.

[DataContract]
[Serializable]
[StructLayout(LayoutKind.Sequential)]
public struct Coordinate
{
    [DataMember(Order = 1)]
    public float X;
    [DataMember(Order = 2)]
    public float Y;
    [DataMember(Order = 3)]
    public float Z;
    [DataMember(Order = 4)]
    [MarshalAs(UnmanagedType.Currency)]
    public decimal Focus;
    [DataMember(Order = 5)]
    [MarshalAs(UnmanagedType.Struct)]
    public Payload Payload;

}

[DataContract]
[Serializable]
[StructLayout(LayoutKind.Sequential,Size = 113)]
public struct Payload
{
    [DataMember(Order = 1)]
    public byte Version;
    [DataMember(Order = 2)]
    public byte Data;
}

Fast byte array comparison in C#

I got into a discussion with a colleague the other day about string comparison in .Net and whether to use

variable.Equals("mystring")

or

"string" == "string"

both in terms of speed (though it wouldn’t matter in most cases) and in terms of readability. As for speed .Equals is faster as you save one method call. == is implemented as an operator which again calls Equals. Our good friend Reflector is always there when you need him.

The interesting part came when reflecting this and I stumbled upon EqualsHelper and CompareOrdinalHelper. Here .Net casts the strings to pointer arrays and compares an int at a time. This lead me to creating a byte[] comparison function after the same code .Net used internally and benchmarking it.

For an equal array with 11 elements the unsafe is 3 times as fast. For unequal arrays the managed implementation is quicker if the first or second byte differs. From the third on and out the unsafe gains speed. Below is some sample code you can experiment with yourself. The longer the array, the more you gain on the unsafe version. Be sure to test the code compile in release mode.

Microsoft don’t recommend you using unsafe unless it’s performance critical, but since they use it internally we can as well ;) (But you should have a good reason due to complexity imo) Why they compare 10 bytes at a time is beyond me and I haven’t tested if this is some magic number which yields good results for general cases.

class Program
{
    static void Main(string[] args)
    {
        byte[] a = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
        byte[] b = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

        Stopwatch sw = new Stopwatch();
        sw.Start();
        for (int i = 0; i < 30000000; i++)
        {
            SafeEquals(a, b);
        }
        sw.Stop();
        Console.WriteLine(sw.Elapsed);

        sw = new Stopwatch();
        sw.Start();
        for (int i = 0; i < 30000000; i++)
        {
            UnSafeEquals(a, b);
        }
        sw.Stop();
        Console.WriteLine(sw.Elapsed);
    }

    private static bool SafeEquals(byte[] strA, byte[] strB)
    {
        int length = strA.Length;
        if (length != strB.Length)
        {
            return false;
        }
        for (int i = 0; i < length; i++)
        {
            if( strA[i] != strB[i] ) return false;
        }
        return true;
    }

    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
    private static unsafe bool UnSafeEquals(byte[] strA, byte[] strB)
    {
        int length = strA.Length;
        if (length != strB.Length)
        {
            return false;
        }
        fixed (byte* str = strA)
        {
            byte* chPtr = str;
            fixed (byte* str2 = strB)
            {
                byte* chPtr2 = str2;
                byte* chPtr3 = chPtr;
                byte* chPtr4 = chPtr2;
                while (length >= 10)
                {
                    if ((((*(((int*)chPtr3)) != *(((int*)chPtr4))) || (*(((int*)(chPtr3 + 2))) != *(((int*)(chPtr4 + 2))))) || ((*(((int*)(chPtr3 + 4))) != *(((int*)(chPtr4 + 4)))) || (*(((int*)(chPtr3 + 6))) != *(((int*)(chPtr4 + 6)))))) || (*(((int*)(chPtr3 + 8))) != *(((int*)(chPtr4 + 8)))))
                    {
                        break;
                    }
                    chPtr3 += 10;
                    chPtr4 += 10;
                    length -= 10;
                }
                while (length > 0)
                {
                    if (*(((int*)chPtr3)) != *(((int*)chPtr4)))
                    {
                        break;
                    }
                    chPtr3 += 2;
                    chPtr4 += 2;
                    length -= 2;
                }
                return (length <= 0);
            }
        }
    }
}