Small cleanup refactoring follow up for pull request 113

1. Factored out four branches in BsonTrieNode.GetChild
  a. Eliminated the need to check _isFrozen
  b. Eliminated the need to check _minKeyByte
  c. Eliminated a CLR bounds check on _keyByteIndexes
  d. Eliminated a CLR bounds check on _children
2. Factored out the maxKeyByte member in BsonTrieNode
3. Refactored a foreach into a for in BsonTrie.TryGetValue (for is faster than foreach on arrays due to better CLR support)
4. Made BsonBuffer.DecodeUtf8String static
5. Factored out a branch in BsonBuffer.DecodeUtf8String
  a. Eliminated a CLR bounds check on __asciiStringTable
6. Updated BsonBuffer.ReadCString to use an Int32 instead of an Object for the default type (carries no GC checking overhead and is the default .Net register type)
7. Fixed a comment typo in BsonTrie.TryGetValue
8. Fixed an XML comment error
9. Switched BsonTrieNode._children from List to Array (Lists are slower than Arrays)

Author: optimiz3

Bson/IO/BsonBuffer.cs

@@ -557,7 +557,7 @@ public string ReadString()
         public string ReadCString()
         {
             bool found;
-            object value;
+            int value;
             return ReadCString(null, out found, out value);
         }
 
@@ -960,28 +960,57 @@ public void WriteZero()
             }
         }
 
-        // private methods
-        private string DecodeUtf8String(byte[] buffer, int index, int count)
+        // private static methods
+        private static string DecodeUtf8String(byte[] buffer, int index, int count)
         {
             switch (count)
             {
                 // special case empty strings
                 case 0:
-                    return "";
+                    return string.Empty;
 
                 // special case single character strings
                 case 1:
-                    var byte1 = (int)buffer[index];
-                    if (byte1 < __asciiStringTable.Length)
+                    var byte1 = buffer[index];
+                    // enable the .Net CLR to eliminate an array bounds check on __asciiStringTable
+                    var asciiStringTable = __asciiStringTable;
+                    if (byte1 < asciiStringTable.Length)
                     {
-                        return __asciiStringTable[byte1];
+                        return asciiStringTable[byte1];
                     }
                     break;
             }
 
             return __utf8Encoding.GetString(buffer, index, count);
         }
 
+        private static int IndexOfNull<TValue>(
+            byte[] buffer,
+            int index,
+            int count,
+            ref BsonTrieNode<TValue> bsonTrieNode)
+        {
+            for (; count > 0; index++, count--)
+            {
+                // bsonTrieNode might be null on entry or it might become null while navigating the trie
+                if (bsonTrieNode == null)
+                {
+                    return Array.IndexOf<byte>(buffer, 0, index, count);
+                }
+
+                var keyByte = buffer[index];
+                if (keyByte == 0)
+                {
+                    return index;
+                }
+
+                bsonTrieNode = bsonTrieNode.GetChild(keyByte); // might return null
+            }
+
+            return -1;
+        }
+
+        // private methods
         private void EnsureDataAvailable(int needed)
         {
             if (_length - _position < needed)
@@ -1013,31 +1042,5 @@ private void EnsureSpaceAvailable(int needed)
                 }
             }
         }
-
-        private static int IndexOfNull<TValue>(
-            byte[] buffer,
-            int index,
-            int count,
-            ref BsonTrieNode<TValue> bsonTrieNode)
-        {
-            for (; count > 0; index++, count--)
-            {
-                // bsonTrieNode might be null on entry or it might become null while navigating the trie
-                if (bsonTrieNode == null)
-                {
-                    return Array.IndexOf<byte>(buffer, 0, index, count);
-                }
-
-                var keyByte = buffer[index];
-                if (keyByte == 0)
-                {
-                    return index;
-                }
-
-                bsonTrieNode = bsonTrieNode.GetChild(keyByte); // might return null
-            }
-
-            return -1;
-        }
     }
 }

Bson/IO/BsonTrie.cs

@@ -15,7 +15,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Text;
 
 namespace MongoDB.Bson.IO
@@ -92,7 +91,7 @@ public void Freeze()
         }
 
         /// <summary>
-        /// Gets the value associated with the specifie element name.
+        /// Gets the value associated with the specified element name.
         /// </summary>
         /// <param name="elementName">The element name.</param>
         /// <param name="value">
@@ -105,25 +104,24 @@ public bool TryGetValue(string elementName, out TValue value)
             var keyBytes = __utf8Encoding.GetBytes(elementName);
 
             var node = _root;
-            foreach (var keyByte in keyBytes)
+            for (var i = 0; i < keyBytes.Length; i++)
             {
-                node = node.GetChild(keyByte);
+                node = node.GetChild(keyBytes[i]);
                 if (node == null)
                 {
-                    break;
+                    value = default(TValue);
+                    return false;
                 }
             }
 
-            if (node != null && node.HasValue)
-            {
-                value = node.Value;
-                return true;
-            }
-            else
+            if (!node.HasValue)
             {
                 value = default(TValue);
                 return false;
             }
+
+            value = node.Value;
+            return true;
         }
     }
 
@@ -137,12 +135,11 @@ public sealed class BsonTrieNode<TValue>
         private string _elementName;
         private TValue _value;
         private BsonTrieNode<TValue> _onlyChild; // used when there is only one child
-        private List<BsonTrieNode<TValue>> _children; // used when there are two or more children
+        private BsonTrieNode<TValue>[] _children; // used when there are two or more children
 
         // private fields set when node is frozen
         private bool _isFrozen;
         private byte _minKeyByte;
-        private byte _maxKeyByte;
         private byte[] _keyByteIndexes; // maps key bytes into indexes into the _children list
 
         // constructors
@@ -212,23 +209,19 @@ public BsonTrieNode<TValue> GetChild(byte keyByte)
             }
             else if (_children != null)
             {
-                if (_isFrozen)
+                var index = (uint)((int)keyByte - _minKeyByte);
+                // enable the .Net CLR to eliminate an array bounds check on _keyByteIndexes
+                var keyByteIndexes = _keyByteIndexes;
+                if (index < keyByteIndexes.Length)
                 {
-                    // once the node is frozen we can use a faster lookup based on fields initialized when Freeze was called
-                    if (keyByte >= _minKeyByte && keyByte <= _maxKeyByte)
+                    index = keyByteIndexes[index];
+                    // enable the .Net CLR to eliminate an array bounds check on _children
+                    var children = _children;
+                    if (index < children.Length)
                     {
-                        var index = _keyByteIndexes[keyByte - _minKeyByte];
-                        if (index < _children.Count)
-                        {
-                            return _children[index];
-                        }
+                        return children[index];
                     }
                 }
-                else
-                {
-                    // until the node is frozen do a simple linear scan of the _children list
-                    return _children.Where(child => child._keyByte == keyByte).SingleOrDefault();
-                }
             }
             return null;
         }
@@ -237,35 +230,39 @@ public BsonTrieNode<TValue> GetChild(byte keyByte)
         internal void AddChild(BsonTrieNode<TValue> child)
         {
             if (_isFrozen) { throw new InvalidOperationException("BsonTrieNode is frozen."); }
-            if (_children == null)
+            if (_children != null)
             {
-                if (_onlyChild == null)
+                if (_children[child._keyByte] != null)
                 {
-                    _onlyChild = child;
+                    throw new ArgumentException("BsonTrieNode already contains a child with the same keyByte.");
                 }
-                else
+
+                _children[child._keyByte] = child;
+            }
+            else if (_onlyChild != null)
+            {
+                if (_onlyChild._keyByte == child._keyByte)
                 {
-                    if (_onlyChild._keyByte == child._keyByte)
-                    {
-                        throw new ArgumentException("BsonTrieNode already contains a child with the same keyByte");
-                    }
+                    throw new ArgumentException("BsonTrieNode already contains a child with the same keyByte.");
+                }
 
-                    var children = new List<BsonTrieNode<TValue>>();
-                    children.Add(_onlyChild);
-                    children.Add(child);
+                var children = new BsonTrieNode<TValue>[256];
+                children[_onlyChild._keyByte] = _onlyChild;
+                children[child._keyByte] = child;
 
-                    _onlyChild = null;
-                    _children = children;
+                var keyByteIndexes = new byte[256];
+                for (var i = 0; i < keyByteIndexes.Length; i++)
+                {
+                    keyByteIndexes[i] = (byte)i;
                 }
+
+                _keyByteIndexes = keyByteIndexes;
+                _onlyChild = null;
+                _children = children;
             }
             else
             {
-                if (_children.Any(n => n._keyByte == child._keyByte))
-                {
-                    throw new ArgumentException("BsonTrieNode already contains a child with the same keyByte");
-                }
-
-                _children.Add(child);
+                _onlyChild = child;
             }
         }
 
@@ -279,18 +276,48 @@ internal void Freeze()
                 }
                 else if (_children != null)
                 {
-                    _children.ForEach(child => child.Freeze());
-                    _minKeyByte = _children.Min(n => n._keyByte);
-                    _maxKeyByte = _children.Max(n => n._keyByte);
-                    _keyByteIndexes = new byte[_maxKeyByte - _minKeyByte + 1];
-                    for (var index = 0; index < _keyByteIndexes.Length; index++)
+                    var i = 0;
+
+                    // _children is guaranteed to have at least one element that isn't null
+                    for (; _children[i] == null; i++);
+
+                    var minKeyByte = (byte)i;
+                    var maxKeyByte = minKeyByte;
+
+                    byte childIndex = 0;
+
+                    for (i++; i < _children.Length; i++)
+                    {
+                        if (_children[i] != null)
+                        {
+                            maxKeyByte = (byte)i;
+                            childIndex++;
+                        }
+                    }
+
+                    var keyByteIndexes = new byte[(int)maxKeyByte - minKeyByte + 1];
+                    for (i = 0; i < keyByteIndexes.Length; i++)
                     {
-                        _keyByteIndexes[index] = 255; // make sure unused entries can be identified
+                        keyByteIndexes[i] = 255; // make sure unused entries can be identified
                     }
-                    for (var index = 0; index < _children.Count; index++)
+
+                    var children = new BsonTrieNode<TValue>[(int)childIndex + 1];
+                    childIndex = 0;
+                    for (i = 0; i < _children.Length; i++)
                     {
-                        _keyByteIndexes[_children[index]._keyByte - _minKeyByte] = (byte)index;
+                        var child = _children[i];
+                        if (child != null)
+                        {
+                            keyByteIndexes[child._keyByte - minKeyByte] = childIndex;
+                            children[childIndex] = child;
+                            child.Freeze();
+                            childIndex++;
+                        }
                     }
+
+                    _minKeyByte = minKeyByte;
+                    _keyByteIndexes = keyByteIndexes;
+                    _children = children;
                 }
                 _isFrozen = true;
             }
@@ -306,6 +333,7 @@ internal void SetValue(string elementName, TValue value)
             {
                 throw new InvalidOperationException("BsonTrieNode already has a value.");
             }
+            if (_isFrozen) { throw new InvalidOperationException("BsonTrieNode is frozen."); }
 
             _elementName = elementName;
             _value = value;

Bson/ObjectModel/BsonDocumentWrapper.cs

@@ -63,8 +63,8 @@ public BsonDocumentWrapper(object wrappedObject)
         /// </summary>
         /// <param name="wrappedNominalType">The nominal type of the wrapped object.</param>
         /// <param name="wrappedObject">The wrapped object.</param>
-        public BsonDocumentWrapper(Type wrappedNominalType, object value)
-            : this(wrappedNominalType, value, false)
+        public BsonDocumentWrapper(Type wrappedNominalType, object wrappedObject)
+            : this(wrappedNominalType, wrappedObject, false)
         {
         }
 

Bson/Serialization/BsonClassMap.cs

@@ -1092,7 +1092,6 @@ private void AutoMapMembers()
                 {
                     _declaredMemberMaps.Sort((x, y) => x.Order.CompareTo(y.Order));
                 }
-
             }
         }