Implement CSHARP-451 (Improve deserialization performance by ~22%).

Deserialization CPU performance was suffering because both LookupDiscriminatorConvention and LookupSerializer were being called for nearly every class member. Both functions take out and release the global config read-lock. Profiling showed that around 22% of all CPU time was being spent in ReaderWriterLockSlim.TryEnterReadLock and ReaderWriterLockSlim.ExitReadLock due to these functions.
Fix makes the BsonClassMap and BsonMemberMap cache references to the appropriate IDiscriminatorConvention and IBsonSerializer instances. By doing this, lookups are avoided while maintaining semantic correctness due to the associated BsonClassMap and BsonMemberMap types never changing once constructed. Incorporated much feedback from discussion with Robert to simplify changes.

Other issues addressed:
1. BsonSerializer.Serialize had a bug where a class implementing IBsonSerializable would always be serialized using the IBsonSerializable implemention, even if the implementation was overridden by a registered IBsonSerializer.
2. Modified BsonSerializer to allow only one custom serializer to be registered. This prevents cache consistency issues when a serializer instance is cached within a BsonMemberMap.

Author: optimiz3

Bson/Serialization/BsonClassMap.cs

@@ -47,6 +47,7 @@ public abstract class BsonClassMap
         private bool _frozen; // once a class map has been frozen no further changes are allowed
         private BsonClassMap _baseClassMap; // null for class object and interfaces
         private Type _classType;
+        private volatile IDiscriminatorConvention _cachedDiscriminatorConvention;
         private Func<object> _creator;
         private ConventionProfile _conventions;
         private string _discriminator;
@@ -965,6 +966,22 @@ public void UnmapProperty(string propertyName)
             UnmapMember(propertyInfo);
         }
 
+        // internal methods
+        /// <summary>
+        /// Gets the discriminator convention for the member type.
+        /// </summary>
+        /// <returns>The discriminator convention for the member type.</returns>
+        internal IDiscriminatorConvention GetDiscriminatorConvention()
+        {
+            var classDiscriminatorConvention = _cachedDiscriminatorConvention;
+            if (classDiscriminatorConvention == null)
+            {
+                classDiscriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(_classType);
+                _cachedDiscriminatorConvention = classDiscriminatorConvention;
+            }
+            return classDiscriminatorConvention;
+        }
+
         // private methods
         private void AutoMapClass()
         {
@@ -1485,7 +1502,7 @@ public void UnmapProperty<TMember>(Expression<Func<TClass, TMember>> propertyLam
             UnmapMember(propertyLambda);
         }
 
-        // private methods
+        // private static methods
         private static MemberInfo GetMemberInfoFromLambda<TMember>(Expression<Func<TClass, TMember>> memberLambda)
         {
             var body = memberLambda.Body;

Bson/Serialization/BsonClassMapSerializer.cs

@@ -63,7 +63,7 @@ public object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializ
             }
             else
             {
-                var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType);
+                var discriminatorConvention = _classMap.GetDiscriminatorConvention();
                 var actualType = discriminatorConvention.GetActualType(bsonReader, nominalType);
                 if (actualType != nominalType)
                 {
@@ -131,7 +131,7 @@ public object Deserialize(
 
                 bsonReader.ReadStartDocument();
                 var missingElementMemberMaps = new HashSet<BsonMemberMap>(classMap.AllMemberMaps); // make a copy!
-                var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType);
+                var discriminatorConvention = classMap.GetDiscriminatorConvention();
                 while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
                 {
                     var elementName = bsonReader.ReadName();
@@ -337,7 +337,7 @@ public void Serialize(
                     // never write out a discriminator for an anonymous class
                     if (!classMap.IsAnonymous)
                     {
-                        var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType);
+                        var discriminatorConvention = classMap.GetDiscriminatorConvention();
                         var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
                         if (discriminator != null)
                         {
@@ -443,7 +443,7 @@ private void DeserializeMember(BsonReader bsonReader, object obj, BsonMemberMap
                 }
                 else
                 {
-                    var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType);
+                    var discriminatorConvention = memberMap.GetDiscriminatorConvention();
                     actualType = discriminatorConvention.GetActualType(bsonReader, nominalType); // returns nominalType if no discriminator found
                 }
                 var serializer = memberMap.GetSerializer(actualType);

Bson/Serialization/BsonMemberMap.cs

@@ -44,6 +44,8 @@ public class BsonMemberMap
         private Action<object, object> _setter;
         private IBsonSerializationOptions _serializationOptions;
         private IBsonSerializer _serializer;
+        private volatile IDiscriminatorConvention _cachedDiscriminatorConvention;
+        private volatile IBsonSerializer _cachedSerializer;
         private IIdGenerator _idGenerator;
         private bool _isRequired;
         private Func<object, bool> _shouldSerializeMethod;
@@ -291,7 +293,20 @@ public IBsonSerializer GetSerializer(Type actualType)
             }
             else
             {
-                return BsonSerializer.LookupSerializer(actualType);
+                if (actualType == _memberType)
+                {
+                    var cachedSerializer = _cachedSerializer;
+                    if (cachedSerializer == null)
+                    {
+                        cachedSerializer = BsonSerializer.LookupSerializer(_memberType);
+                        _cachedSerializer = cachedSerializer;
+                    }
+                    return cachedSerializer;
+                }
+                else
+                {
+                    return BsonSerializer.LookupSerializer(actualType);
+                }
             }
         }
 
@@ -483,6 +498,22 @@ public bool ShouldSerialize(object obj, object value)
             return true;
         }
 
+        // internal methods
+        /// <summary>
+        /// Gets the discriminator convention for the member type.
+        /// </summary>
+        /// <returns>The discriminator convention for the member type.</returns>
+        internal IDiscriminatorConvention GetDiscriminatorConvention()
+        {
+            var classDiscriminatorConvention = _cachedDiscriminatorConvention;
+            if (classDiscriminatorConvention == null)
+            {
+                classDiscriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(_memberType);
+                _cachedDiscriminatorConvention = classDiscriminatorConvention;
+            }
+            return classDiscriminatorConvention;
+        }
+
         // private methods
         private static object GetDefaultValue(Type type)
         {

Bson/Serialization/BsonSerializer.cs

@@ -43,7 +43,6 @@ public static class BsonSerializer
         // static constructor
         static BsonSerializer()
         {
-            RegisterDefaultSerializationProvider();
             RegisterIdGenerators();
         }
 
@@ -359,7 +358,7 @@ public static IIdGenerator LookupIdGenerator(Type type)
         }
 
         /// <summary>
-        /// Looks up a serializer for a Type.
+        /// Looks up and populates the serializer singleton for a type.
         /// </summary>
         /// <param name="type">The Type.</param>
         /// <returns>A serializer for the Type.</returns>
@@ -368,7 +367,7 @@ public static IBsonSerializer LookupSerializer(Type type)
             __configLock.EnterReadLock();
             try
             {
-                IBsonSerializer serializer;
+               IBsonSerializer serializer;
                 if (__serializers.TryGetValue(type, out serializer))
                 {
                     return serializer;
@@ -385,6 +384,18 @@ public static IBsonSerializer LookupSerializer(Type type)
                 IBsonSerializer serializer;
                 if (!__serializers.TryGetValue(type, out serializer))
                 {
+                    if (serializer == null)
+                    {
+                        foreach (var serializationProvider in __serializationProviders)
+                        {
+                            serializer = serializationProvider.GetSerializer(type);
+                            if (serializer != null)
+                            {
+                                break;
+                            }
+                        }
+                    }
+
                     // special case for IBsonSerializable
                     if (serializer == null && typeof(IBsonSerializable).IsAssignableFrom(type))
                     {
@@ -404,14 +415,7 @@ public static IBsonSerializer LookupSerializer(Type type)
 
                     if (serializer == null)
                     {
-                        foreach (var serializationProvider in __serializationProviders)
-                        {
-                            serializer = serializationProvider.GetSerializer(type);
-                            if (serializer != null)
-                            {
-                                break;
-                            }
-                        }
+                        serializer = BsonDefaultSerializer.Instance.GetSerializer(type);
                     }
 
                     if (serializer == null)
@@ -475,6 +479,11 @@ public static void RegisterIdGenerator(Type type, IIdGenerator idGenerator)
         /// <param name="provider">The serialization provider.</param>
         public static void RegisterSerializationProvider(IBsonSerializationProvider provider)
         {
+            if (provider == BsonDefaultSerializer.Instance)
+            {
+                throw new ArgumentException("BsonDefaultSerializer is implicitly registered", "provider");
+            }
+
             __configLock.EnterWriteLock();
             try
             {
@@ -497,7 +506,12 @@ public static void RegisterSerializer(Type type, IBsonSerializer serializer)
             __configLock.EnterWriteLock();
             try
             {
-                __serializers[type] = serializer;
+                if (__serializers.ContainsKey(type))
+                {
+                    var message = string.Format("There is already a serializer registered for type {0}.", type.FullName);
+                    throw new BsonSerializationException(message);
+                }
+                __serializers.Add(type, serializer);
             }
             finally
             {
@@ -555,24 +569,12 @@ public static void Serialize(
             object value,
             IBsonSerializationOptions options)
         {
-            var bsonSerializable = value as IBsonSerializable;
-            if (bsonSerializable != null)
-            {
-                bsonSerializable.Serialize(bsonWriter, nominalType, options);
-                return;
-            }
-
             var actualType = (value == null) ? nominalType : value.GetType();
             var serializer = LookupSerializer(actualType);
             serializer.Serialize(bsonWriter, nominalType, value, options);
         }
 
         // private static methods
-        private static void RegisterDefaultSerializationProvider()
-        {
-            RegisterSerializationProvider(BsonDefaultSerializer.Instance);
-        }
-
         private static void RegisterIdGenerators()
         {
             BsonSerializer.RegisterIdGenerator(typeof(BsonObjectId), BsonObjectIdGenerator.Instance);