Update CSHARP-452 (Improve deserialization performance)

    Robert and I had been discussing CHARP-4522 and we accidentally both implemented this separately. This merges the best parts from both of our work. (My original implementation can be found here optimiz3@f165220.)

    This change uses an O(1) bit array when determining which elements have been deserialized. One trick it uses is leveraging how .Net default initializes array values to 0 for the bit array. It also significantly enhances sparse structure processing.

    After running several tests I found this improved deserialization performance by an average 7% in the dense structure case and an average 27% in the sparse structure case over the current build in mainline.

Author: optimiz3

Bson/Serialization/BsonClassMap.cs

@@ -15,6 +15,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.IO;
 using System.Linq;
 using System.Linq.Expressions;
@@ -56,12 +57,14 @@ public abstract class BsonClassMap
         private bool _isRootClass;
         private bool _isAnonymous;
         private BsonMemberMap _idMemberMap;
-        private List<BsonMemberMap> _allMemberMaps = new List<BsonMemberMap>(); // includes inherited member maps
+        private readonly List<BsonMemberMap> _allMemberMaps; // includes inherited member maps
+        private readonly ReadOnlyCollection<BsonMemberMap> _allMemberMapsReadonly;
         private List<BsonMemberMap> _declaredMemberMaps = new List<BsonMemberMap>(); // only the members declared in this class
-        private Dictionary<string, BsonMemberMap> _elementDictionary = new Dictionary<string, BsonMemberMap>();
+        private readonly Dictionary<string, int> _elementDictionary;
         private bool _ignoreExtraElements = true;
         private bool _ignoreExtraElementsIsInherited = false;
         private BsonMemberMap _extraElementsMemberMap;
+        private int _extraElementsMemberIndex = -1;
         private List<Type> _knownTypes = new List<Type>();
 
         // constructors
@@ -75,15 +78,18 @@ protected BsonClassMap(Type classType)
             _conventions = LookupConventions(classType);
             _discriminator = classType.Name;
             _isAnonymous = IsAnonymousType(classType);
+            _allMemberMaps = new List<BsonMemberMap>();
+            _allMemberMapsReadonly = _allMemberMaps.AsReadOnly();
+            _elementDictionary = new Dictionary<string, int>();
         }
 
         // public properties
         /// <summary>
         /// Gets all the member maps (including maps for inherited members).
         /// </summary>
-        public IEnumerable<BsonMemberMap> AllMemberMaps
+        public ReadOnlyCollection<BsonMemberMap> AllMemberMaps
         {
-            get { return _allMemberMaps; }
+            get { return _allMemberMapsReadonly; }
         }
 
         /// <summary>
@@ -215,6 +221,15 @@ public IEnumerable<BsonMemberMap> MemberMaps
             get { return _allMemberMaps; }
         }
 
+        // internal properties
+        /// <summary>
+        /// Gets the member index of the member used to hold extra elements.
+        /// </summary>
+        internal int ExtraElementsMemberMapIndex
+        {
+            get { return _extraElementsMemberIndex; }
+        }
+
         // public static methods
         /// <summary>
         /// Gets the type of a member.
@@ -518,15 +533,18 @@ public BsonClassMap Freeze()
                             }
                         }
 
-                        foreach (var memberMap in _allMemberMaps)
+                        _extraElementsMemberIndex = -1;
+                        for (int memberIndex = 0; memberIndex < _allMemberMaps.Count; ++memberIndex)
                         {
-                            BsonMemberMap conflictingMemberMap;
-                            if (!_elementDictionary.TryGetValue(memberMap.ElementName, out conflictingMemberMap))
+                            var memberMap = _allMemberMaps[memberIndex];
+                            int conflictingMemberIndex;
+                            if (!_elementDictionary.TryGetValue(memberMap.ElementName, out conflictingMemberIndex))
                             {
-                                _elementDictionary.Add(memberMap.ElementName, memberMap);
+                                _elementDictionary.Add(memberMap.ElementName, memberIndex);
                             }
                             else
                             {
+                                var conflictingMemberMap = _allMemberMaps[conflictingMemberIndex];
                                 var fieldOrProperty = (memberMap.MemberInfo.MemberType == MemberTypes.Field) ? "field" : "property";
                                 var conflictingFieldOrProperty = (conflictingMemberMap.MemberInfo.MemberType == MemberTypes.Field) ? "field" : "property";
                                 var conflictingType = conflictingMemberMap.MemberInfo.DeclaringType;
@@ -546,6 +564,10 @@ public BsonClassMap Freeze()
                                 }
                                 throw new BsonSerializationException(message);
                             }
+                            if (memberMap == _extraElementsMemberMap)
+                            {
+                                _extraElementsMemberIndex = memberIndex;
+                            }
                         }
 
                         // mark this classMap frozen before we start working on knownTypes
@@ -611,8 +633,12 @@ public BsonMemberMap GetMemberMapForElement(string elementName)
             }
 
             if (!_frozen) { ThrowNotFrozenException(); }
-            BsonMemberMap memberMap;
-            _elementDictionary.TryGetValue(elementName, out memberMap);
+            int memberIndex;
+            if (!_elementDictionary.TryGetValue(elementName, out memberIndex))
+            {
+                return null;
+            }
+            var memberMap = _allMemberMaps[memberIndex];
             return memberMap;
         }
 
@@ -984,6 +1010,27 @@ internal IDiscriminatorConvention GetDiscriminatorConvention()
             return discriminatorConvention;
         }
 
+        /// <summary>
+        /// Gets the member map for a BSON element.
+        /// </summary>
+        /// <param name="elementName">The name of the element.</param>
+        /// <returns>The member map.</returns>
+        internal int GetMemberMapIndexForElement(string elementName)
+        {
+            if (elementName == null)
+            {
+                throw new ArgumentNullException("elementName");
+            }
+
+            if (!_frozen) { ThrowNotFrozenException(); }
+            int memberMapIndex;
+            if (!_elementDictionary.TryGetValue(elementName, out memberMapIndex))
+            {
+                return -1;
+            }
+            return memberMapIndex;
+        }
+
         // private methods
         private void AutoMapClass()
         {

Bson/Serialization/BsonClassMapSerializer.cs

@@ -135,7 +135,9 @@ public object Deserialize(
                 }
 
                 var discriminatorConvention = _classMap.GetDiscriminatorConvention();
-                var fastMemberMapFinder = new FastMemberMapFinder(_classMap);
+                var allMemberMaps = _classMap.AllMemberMaps;
+                var extraElementsMemberMapIndex = _classMap.ExtraElementsMemberMapIndex;
+                var memberMapBitArray = FastMemberMapHelper.GetBitArray(allMemberMaps.Count);
 
                 bsonReader.ReadStartDocument();
                 while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
@@ -147,9 +149,10 @@ public object Deserialize(
                         continue;
                     }
 
-                    var memberMap = fastMemberMapFinder.GetMemberMapForElement(elementName);
-                    if (memberMap != null)
+                    var memberMapIndex = _classMap.GetMemberMapIndexForElement(elementName);
+                    if (memberMapIndex >= 0 && memberMapIndex != extraElementsMemberMapIndex)
                     {
+                        var memberMap = allMemberMaps[memberMapIndex];
                         if (memberMap.IsReadOnly)
                         {
                             bsonReader.SkipValue();
@@ -158,12 +161,14 @@ public object Deserialize(
                         {
                             DeserializeMember(bsonReader, obj, memberMap);
                         }
+                        memberMapBitArray[memberMapIndex >> 5] |= 1U << (memberMapIndex & 31);
                     }
                     else
                     {
-                        if (_classMap.ExtraElementsMemberMap != null)
+                        if (extraElementsMemberMapIndex >= 0)
                         {
                             DeserializeExtraElement(bsonReader, obj, elementName, _classMap.ExtraElementsMemberMap);
+                            memberMapBitArray[extraElementsMemberMapIndex >> 5] |= 1U << (extraElementsMemberMapIndex & 31);
                         }
                         else if (_classMap.IgnoreExtraElements)
                         {
@@ -181,25 +186,38 @@ public object Deserialize(
                 bsonReader.ReadEndDocument();
 
                 // check any members left over that we didn't have elements for
-                if (fastMemberMapFinder.HasLeftOverMemberMaps())
+                for (var bitArrayIndex = 0; bitArrayIndex < memberMapBitArray.Length; ++bitArrayIndex)
                 {
-                    foreach (var memberMap in fastMemberMapFinder.GetLeftOverMemberMaps())
+                    var memberMapIndex = bitArrayIndex << 5;
+                    var memberMapBlock = ~memberMapBitArray[bitArrayIndex];
+
+                    for (;;)
                     {
-                        if (memberMap.IsReadOnly)
+                        while ((memberMapBlock & 1) != 0)
                         {
-                            continue;
+                            var memberMap = allMemberMaps[memberMapIndex];
+                            if (memberMap.IsRequired)
+                            {
+                                var fieldOrProperty = (memberMap.MemberInfo.MemberType == MemberTypes.Field) ? "field" : "property";
+                                var message = string.Format(
+                                    "Required element '{0}' for {1} '{2}' of class {3} is missing.",
+                                    memberMap.ElementName, fieldOrProperty, memberMap.MemberName, _classMap.ClassType.FullName);
+                                throw new FileFormatException(message);
+                            }
+                            memberMap.ApplyDefaultValue(obj);
+
+                            ++memberMapIndex;
+                            memberMapBlock >>= 1;
                         }
 
-                        if (memberMap.IsRequired)
+                        if (memberMapBlock == 0)
                         {
-                            var fieldOrProperty = (memberMap.MemberInfo.MemberType == MemberTypes.Field) ? "field" : "property";
-                            var message = string.Format(
-                                "Required element '{0}' for {1} '{2}' of class {3} is missing.",
-                                memberMap.ElementName, fieldOrProperty, memberMap.MemberName, _classMap.ClassType.FullName);
-                            throw new FileFormatException(message);
+                            break;
                         }
 
-                        memberMap.ApplyDefaultValue(obj);
+                        var leastSignificantBit = FastMemberMapHelper.GetLeastSignificantBit(memberMapBlock);
+                        memberMapIndex += leastSignificantBit;
+                        memberMapBlock >>= leastSignificantBit;
                     }
                 }
 
@@ -359,18 +377,22 @@ public void Serialize(
                     }
                 }
 
-                foreach (var memberMap in _classMap.AllMemberMaps)
+                var allMemberMaps = _classMap.AllMemberMaps;
+                var extraElementsMemberMapIndex = _classMap.ExtraElementsMemberMapIndex;
+
+                for (var memberMapIndex = 0; memberMapIndex < allMemberMaps.Count; ++memberMapIndex)
                 {
+                    var memberMap = allMemberMaps[memberMapIndex];
                     // note: if serializeIdFirst is false then idMemberMap will be null (so no property will be skipped)
                     if (memberMap != idMemberMap)
                     {
-                        if (memberMap == _classMap.ExtraElementsMemberMap)
+                        if (memberMapIndex != extraElementsMemberMapIndex)
                         {
-                            SerializeExtraElements(bsonWriter, value, memberMap);
+                            SerializeMember(bsonWriter, value, memberMap);
                         }
                         else
                         {
-                            SerializeMember(bsonWriter, value, memberMap);
+                            SerializeExtraElements(bsonWriter, value, memberMap);
                         }
                     }
                 }
@@ -531,90 +553,35 @@ private void VerifyNominalType(Type nominalType)
         }
 
         // nested classes
-        // helper class that implements fast linear searching of member maps by using a shrinking range
-        // and optimized for the case when the elements occur in the same order as the maps
-        private class FastMemberMapFinder
+        // helper class that implements member map bit array helper functions
+        private static class FastMemberMapHelper
         {
-            private BsonClassMap _classMap;
-            private BsonMemberMap _extraElementsMemberMap;
-            private BsonMemberMap[] _memberMaps;
-            private int _from;
-            private int _to;
-
-            public FastMemberMapFinder(BsonClassMap classMap)
+            private static readonly byte[] __multiplyDeBruijnBitIndex =
             {
-                _classMap = classMap;
-                _extraElementsMemberMap = classMap.ExtraElementsMemberMap;
-                _memberMaps = classMap.AllMemberMaps.ToArray();
-                _from = 0;
-                _to = _memberMaps.Length - 1;
-                if (_extraElementsMemberMap != null)
-                {
-                    var i = Array.IndexOf(_memberMaps, _extraElementsMemberMap);
-                    _memberMaps[i] = null;
-                }
-            }
-
-            public BsonMemberMap GetMemberMapForElement(string elementName)
-            {
-                // linear search should be fast because elements will normally be in the same order as the member maps
-                for (int i = _from; i <= _to; i++)
-                {
-                    var memberMap = _memberMaps[i];
-                    if (memberMap == null)
-                    {
-                        if (i == _from)
-                        {
-                            _from++; // shrink the range from the left
-                        }
-                        continue;
-                    }
+                0, 1, 28, 2, 29, 14, 24, 3,
+                30, 22, 20, 15, 25, 17, 4, 8,
+                31, 27, 13, 23, 21, 19, 16, 7,
+                26, 12, 18, 6, 11, 5, 10, 9,
+            };
 
-                    if (memberMap.ElementName == elementName)
-                    {
-                        if (i == _from)
-                        {
-                            _from++; // shrink the range from the left
-                        }
-                        else if (i == _to)
-                        {
-                            _to--; // shrink the range from the right
-                        }
-                        else
-                        {
-                            _memberMaps[i] = null; // set to null so we don't think it's missing
-                        }
-                        return memberMap;
-                    }
-                }
-
-                // fall back to the class map in case it's a duplicate element name that we've already null'ed out
-                // but make sure not to return the extraElementsMemberMap
-                if (_extraElementsMemberMap == null || elementName != _extraElementsMemberMap.ElementName)
-                {
-                    return _classMap.GetMemberMapForElement(elementName);
-                }
-                else
-                {
-                    return null;
-                }
-            }
-
-            public bool HasLeftOverMemberMaps()
+            public static uint[] GetBitArray(int memberCount)
             {
-                for (int i = _from; i <= _to; i++)
+                var bitArrayOffset = memberCount & 31;
+                var bitArrayLength = memberCount >> 5;
+                if (bitArrayOffset == 0)
                 {
-                    if (_memberMaps[i] != null)
-                    {
-                        return true;
-                    }
+                    return new uint[bitArrayLength];
                 }
-                return false;
+                var bitArray = new uint[bitArrayLength + 1];
+                bitArray[bitArrayLength] = ~0U << bitArrayOffset; // set unused bits to 1
+                return bitArray;
             }
 
-            public IEnumerable<BsonMemberMap> GetLeftOverMemberMaps()
+            // see http://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightMultLookup
+            // also returns 0 if no bits are set; caller must check this case
+            public static int GetLeastSignificantBit(uint bitBlock)
             {
-                return _memberMaps.Where((m, i) => (i >= _from) && (i <= _to) && (m != null));
+                return __multiplyDeBruijnBitIndex[((uint)((bitBlock & -bitBlock) * 0x077cb531U)) >> 27];
             }
         }
     }