Improve deserialization performance by > 40% in the normal case and > 25% in the worst case.

Profiling showed that during deserialization, significant time was being spent in the following functions:
1. System.Type.IsAssignableFrom(class System.Type)	14.35%
2. MongoDB.Bson.IO.BsonBinaryReader.ReadBsonType() 11.46%
3. MongoDB.Bson.Serialization.BsonClassMap.GetMemberMapIndexForElement(string) 7.68%

This change addresses all 3 items:
1. Fixed by placing a quick type check before the hot path IsAssignableFrom calls. In most cases the types are equivalent which eliminates the call to IsAssignableFrom.
2/3. Most of the time in ReadBsonType is due to a call to ReadCString. All of the calls to GetMemberMapIndexForElement use the value returned by ReadCString. To improve this, I've implemented a trie (http://en.wikipedia.org/wiki/Trie) optimized for mapping input bytes sequences directly to result values specified by the caller. In the case of BsonClassMapSerializer, the trie directly maps the input binary UTF8 representation of element names to member map indexes. This completely eliminates all dictionary lookups, UTF8 string conversions, intermediary memory allocation, and does so in O(m) time where m is the length of the input string. Contrast this with the existing implementation where there are 5 (!!!) O(m) operations (1. Find the null byte, 2. Count the number of UTF8 characters, 3. Decode the UTF8 characters into a string, 4. Hash the string, 5. Compare the string the key in the hashtable bucket).  Additionally, I’ve factored the trie so any deserializer can make use of one when decoding to immediately switch to the correct state when decoding.

Additionally I’ve also implemented two other minor improvements:
1. Replaced the lookup table based GetLeastSignificantBit implementation in BsonClassMapSerializer with a binary search based one.  This is significantly faster on .Net because array accesses require an indirection and a managed bounds check.  In my own side by side testing, the binary search based one is 40-50% faster.
2. Added the readonly attribute to _declaredMemberMaps in BsonClassMap and cleaned up the initialization of this value. Minor improvement but the field is now consistent with _allMemberMaps and fewer copies happen during construction.

Author: optimiz3

Bson/Bson.csproj

@@ -86,6 +86,7 @@
     <Compile Include="IO\BsonDocumentReaderSettings.cs" />
     <Compile Include="IO\BsonDocumentWriterSettings.cs" />
     <Compile Include="IO\BsonReaderSettings.cs" />
+    <Compile Include="IO\BsonTrie.cs" />
     <Compile Include="IO\BsonWriterSettings.cs" />
     <Compile Include="ObjectModel\GuidRepresentation.cs" />
     <Compile Include="ObjectModel\GuidConverter.cs" />

Bson/IO/BsonBinaryReader.cs

@@ -161,7 +161,7 @@ public override bool ReadBoolean()
         /// Reads a BsonType from the reader.
         /// </summary>
         /// <returns>A BsonType.</returns>
-        public override BsonType ReadBsonType()
+        public override BsonType ReadBsonType(BsonTrie bsonTrie)
         {
             if (Disposed) { ThrowObjectDisposedException(); }
             if (State == BsonReaderState.Initial || State == BsonReaderState.Done || State == BsonReaderState.ScopeDocument)
@@ -204,7 +204,7 @@ public override BsonType ReadBsonType()
                         break;
                     case ContextType.Document:
                     case ContextType.ScopeDocument:
-                        CurrentName = _buffer.ReadCString();
+                        CurrentName = _buffer.ReadCString(bsonTrie);
                         State = BsonReaderState.Name;
                         break;
                     default:
@@ -417,8 +417,8 @@ public override void ReadRegularExpression(out string pattern, out string option
         {
             if (Disposed) { ThrowObjectDisposedException(); }
             VerifyBsonType("ReadRegularExpression", BsonType.RegularExpression);
-            pattern = _buffer.ReadCString();
-            options = _buffer.ReadCString();
+            pattern = (string)_buffer.ReadCString(null);
+            options = (string)_buffer.ReadCString(null);
             State = GetNextState();
         }
 

Bson/IO/BsonBinaryReaderBookmark.cs

@@ -33,7 +33,7 @@ public class BsonBinaryReaderBookmark : BsonReaderBookmark
         internal BsonBinaryReaderBookmark(
             BsonReaderState state,
             BsonType currentBsonType,
-            string currentName,
+            object currentName,
             BsonBinaryReaderContext context,
             int position)
             : base(state, currentBsonType, currentName)

Bson/IO/BsonBuffer.cs

@@ -144,11 +144,11 @@ public int Position
         // private static methods
         private static string[] BuildAsciiStringTable()
         {
-            var asciiStringTable = new string[128];
+            var asciiStringTable = new string[95]; // 95 printable ASCII characters; first 32 are control characters; 127 is the delete character
 
-            for (int i = 0; i < 128; ++i)
+            for (var i = 0; i < asciiStringTable.Length; ++i)
             {
-                asciiStringTable[i] = new string((char)i, 1);
+                asciiStringTable[i] = new string((char)(i + 32), 1);
             }
 
             return asciiStringTable;
@@ -533,31 +533,7 @@ public string ReadString()
                 {
                     throw new FileFormatException("String is missing null terminator.");
                 }
-
-                switch (length)
-                {
-                    // special case empty strings
-                    case 1:
-                        value = string.Empty;
-                        break;
-
-                    // special case single character strings
-                    case 2:
-                        var c1 = _chunk[_chunkOffset];
-                        if (c1 < 128)
-                        {
-                            value = __asciiStringTable[c1];
-                        }
-                        else
-                        {
-                            value = __utf8Encoding.GetString(_chunk, _chunkOffset, 1); // let GetString throw a DecoderFallbackException
-                        }
-                        break;
-
-                    default:
-                        value = __utf8Encoding.GetString(_chunk, _chunkOffset, length - 1); // don't decode the null terminator
-                        break;
-                }
+                value = GetSingleChunkString(length - 1); // don't decode the null terminator
                 Position += length;
             }
             else
@@ -577,8 +553,9 @@ public string ReadString()
         /// <summary>
         /// Reads a BSON CString from the reader (a null terminated string).
         /// </summary>
-        /// <returns>A String.</returns>
-        public string ReadCString()
+        /// <param name="bsonTrie">An optional BsonTrie to use during decoding.</param>
+        /// <returns>A value decoded using the optional BsonTrie or a String if no BsonTrie was specified or no value could be decoded using the BsonTrie.</returns>
+        public object ReadCString(BsonTrie bsonTrie)
         {
             if (_disposed) { throw new ObjectDisposedException("BsonBuffer"); }
             // optimize for the case where the null terminator is on the same chunk
@@ -592,44 +569,20 @@ public string ReadCString()
                 partialCount = _length - _position; // populated part of last chunk
             }
 
-            if (partialCount > 0)
+            var bsonTrieNode = bsonTrie != null ? bsonTrie.Root : null;
+            var index = FindNull(
+                bsonTrie,
+                ref bsonTrieNode,
+                _chunk,
+                _chunkOffset,
+                partialCount);
+            if (index != -1)
             {
-                var c1 = _chunk[_chunkOffset];
-
-                // special case empty strings
-                if (c1 == 0)
-                {
-                    Position += 1;
-                    return string.Empty;
-                }
-
-                if (partialCount > 1)
-                {
-                    // special case single character strings
-                    if (_chunk[_chunkOffset + 1] == 0)
-                    {
-                        string value;
-                        if (c1 < 128)
-                        {
-                            value = __asciiStringTable[c1];
-                        }
-                        else
-                        {
-                            value = __utf8Encoding.GetString(_chunk, _chunkOffset, 1); // let GetString throw a DecoderFallbackException
-                        }
-                        Position += 2;
-                        return value;
-                    }
-
-                    var index = Array.IndexOf<byte>(_chunk, 0, _chunkOffset + 2, partialCount - 2);
-                    if (index != -1)
-                    {
-                        var stringLength = index - _chunkOffset;
-                        var value = __utf8Encoding.GetString(_chunk, _chunkOffset, stringLength);
-                        Position += stringLength + 1;
-                        return value;
-                    }
-                }
+                var stringLength = index - _chunkOffset;
+                var value = bsonTrieNode != null && bsonTrieNode.HasValue ?
+                    bsonTrieNode.Value : GetSingleChunkString(stringLength);
+                Position += stringLength + 1;
+                return value;
             }
 
             // the null terminator is not on the same chunk so keep looking starting with the next chunk
@@ -646,13 +599,27 @@ public string ReadCString()
                 {
                     partialCount = _length - localPosition; // populated part of last chunk
                 }
-                var index = Array.IndexOf<byte>(localChunk, 0, 0, partialCount);
+                index = FindNull(
+                    bsonTrie,
+                    ref bsonTrieNode,
+                    localChunk,
+                    0,
+                    partialCount);
                 if (index != -1)
                 {
                     localPosition += index;
                     var stringLength = localPosition - _position;
-                    var value = __utf8Encoding.GetString(ReadBytes(stringLength)); // ReadBytes advances over string
-                    Position += 1; // skip over null byte at end
+                    object value;
+                    if (bsonTrieNode != null && bsonTrieNode.HasValue)
+                    {
+                        value = bsonTrieNode.Value;
+                        Position += stringLength + 1;
+                    }
+                    else
+                    {
+                        value = __utf8Encoding.GetString(ReadBytes(stringLength)); // ReadBytes advances over string
+                        Position += 1; // skip over null byte at end
+                    }
                     return value;
                 }
                 localChunkIndex++;
@@ -1009,5 +976,64 @@ private void EnsureSpaceAvailable(int needed)
                 }
             }
         }
+
+        private static int FindNull(
+            BsonTrie bsonTrie,
+            ref BsonTrieNode bsonTrieNode,
+            byte[] buffer,
+            int index,
+            int count)
+        {
+            while (count > 0)
+            {
+                if (bsonTrieNode == null)
+                {
+                    return Array.IndexOf<byte>(buffer, 0, index, count);
+                }
+
+                var c = buffer[index];
+
+                if (c == 0)
+                {
+                    if (!bsonTrieNode.HasValue)
+                    {
+                        bsonTrieNode = null;
+                    }
+
+                    return index;
+                }
+
+                bsonTrieNode = bsonTrie.GetNext(
+                    bsonTrieNode,
+                    c);
+
+                ++index;
+
+                --count;
+            }
+
+            return -1;
+        }
+
+        private string GetSingleChunkString(int length)
+        {
+            switch (length)
+            {
+                // special case empty strings
+                case 0:
+                    return string.Empty;
+
+                // special case single character strings
+                case 1:
+                    int tableIndex = _chunk[_chunkOffset] - 32;
+                    if ((uint)tableIndex < __asciiStringTable.Length)
+                    {
+                        return __asciiStringTable[tableIndex];
+                    }
+                    break;
+            }
+
+            return __utf8Encoding.GetString(_chunk, _chunkOffset, length);
+        }
     }
 }

Bson/IO/BsonDocumentReader.cs

@@ -104,7 +104,7 @@ public override bool ReadBoolean()
         /// Reads a BsonType from the reader.
         /// </summary>
         /// <returns>A BsonType.</returns>
-        public override BsonType ReadBsonType()
+        public override BsonType ReadBsonType(BsonTrie bsonTrie)
         {
             if (Disposed) { ThrowObjectDisposedException(); }
             if (State == BsonReaderState.Initial || State == BsonReaderState.ScopeDocument)
@@ -137,7 +137,16 @@ public override BsonType ReadBsonType()
                         State = BsonReaderState.EndOfDocument;
                         return BsonType.EndOfDocument;
                     }
-                    CurrentName = currentElement.Name;
+                    object currentName;
+                    if (bsonTrie != null &&
+                        bsonTrie.TryGetValue(currentElement.Name, out currentName))
+                    {
+                        CurrentName = currentName;
+                    }
+                    else
+                    {
+                        CurrentName = currentElement.Name;
+                    }
                     _currentValue = currentElement.Value;
                     State = BsonReaderState.Name;
                     break;

Bson/IO/BsonDocumentReaderBookmark.cs

@@ -33,7 +33,7 @@ public class BsonDocumentReaderBookmark : BsonReaderBookmark
         internal BsonDocumentReaderBookmark(
             BsonReaderState state,
             BsonType currentBsonType,
-            string currentName,
+            object currentName,
             BsonDocumentReaderContext context,
             BsonValue currentValue)
             : base(state, currentBsonType, currentName)

Bson/IO/BsonReader.cs

@@ -31,7 +31,7 @@ public abstract class BsonReader : IDisposable
         private BsonReaderSettings _settings;
         private BsonReaderState _state;
         private BsonType _currentBsonType;
-        private string _currentName;
+        private object _currentName;
 
         // constructors
         /// <summary>
@@ -54,6 +54,15 @@ public BsonType CurrentBsonType
             protected set { _currentBsonType = value; }
         }
 
+        /// <summary>
+        /// Gets the current name.
+        /// </summary>
+        public object CurrentName
+        {
+            get { return _currentName; }
+            protected set { _currentName = value; }
+        }
+
         /// <summary>
         /// Gets the settings of the reader.
         /// </summary>
@@ -72,15 +81,6 @@ public BsonReaderState State
         }
 
         // protected properties
-        /// <summary>
-        /// Gets the current name.
-        /// </summary>
-        protected string CurrentName
-        {
-            get { return _currentName; }
-            set { _currentName = value; }
-        }
-
         /// <summary>
         /// Gets whether the BsonReader has been disposed.
         /// </summary>
@@ -364,11 +364,17 @@ public bool ReadBoolean(string name)
             return ReadBoolean();
         }
 
+        /// <returns>A BsonType.</returns>
+        public BsonType ReadBsonType()
+        {
+            return this.ReadBsonType(null);
+        }
+
         /// <summary>
         /// Reads a BsonType from the reader.
         /// </summary>
         /// <returns>A BsonType.</returns>
-        public abstract BsonType ReadBsonType();
+        public abstract BsonType ReadBsonType(BsonTrie bsonTrie);
 
         /// <summary>
         /// Reads a BSON DateTime from the reader.
@@ -529,7 +535,7 @@ public string ReadName()
             }
 
             _state = BsonReaderState.Value;
-            return _currentName;
+            return _currentName as string;
         }
 
         /// <summary>

Bson/IO/BsonReaderBookmark.cs

@@ -28,7 +28,7 @@ public abstract class BsonReaderBookmark
         // private fields
         private BsonReaderState _state;
         private BsonType _currentBsonType;
-        private string _currentName;
+        private object _currentName;
 
         // constructors
         /// <summary>
@@ -37,7 +37,7 @@ public abstract class BsonReaderBookmark
         /// <param name="state">The state of the reader.</param>
         /// <param name="currentBsonType">The current BSON type.</param>
         /// <param name="currentName">The name of the current element.</param>
-        protected BsonReaderBookmark(BsonReaderState state, BsonType currentBsonType, string currentName)
+        protected BsonReaderBookmark(BsonReaderState state, BsonType currentBsonType, object currentName)
         {
             _state = state;
             _currentBsonType = currentBsonType;
@@ -64,7 +64,7 @@ public BsonType CurrentBsonType
         /// <summary>
         /// Gets the name of the current element.
         /// </summary>
-        public string CurrentName
+        public object CurrentName
         {
             get { return _currentName; }
         }