Speeding up decimal (de)serialization.

Author: Stefán J. Sigurðarson

projects/RabbitMQ.Client/client/impl/WireFormatting.cs

@@ -34,32 +34,56 @@
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Text;
+
 using RabbitMQ.Client.Exceptions;
 using RabbitMQ.Util;
 
 namespace RabbitMQ.Client.Impl
 {
+    // * DESCRIPTION TAKEN FROM MS REFERENCE SOURCE *
+    // https://github.com/microsoft/referencesource/blob/master/mscorlib/system/decimal.cs
+    // The lo, mid, hi, and flags fields contain the representation of the
+    // Decimal value. The lo, mid, and hi fields contain the 96-bit integer
+    // part of the Decimal. Bits 0-15 (the lower word) of the flags field are
+    // unused and must be zero; bits 16-23 contain must contain a value between
+    // 0 and 28, indicating the power of 10 to divide the 96-bit integer part
+    // by to produce the Decimal value; bits 24-30 are unused and must be zero;
+    // and finally bit 31 indicates the sign of the Decimal value, 0 meaning
+    // positive and 1 meaning negative.
+    readonly struct DecimalData
+    {
+        public readonly uint Flags;
+        public readonly uint Hi;
+        public readonly uint Lo;
+        public readonly uint Mid;
+
+        internal DecimalData(uint flags, uint hi, uint lo, uint mid)
+        {
+            Flags = flags;
+            Hi = hi;
+            Lo = lo;
+            Mid = mid;
+        }
+    }
+
     internal static class WireFormatting
     {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static decimal ReadDecimal(ReadOnlySpan<byte> span)
         {
             byte scale = span[0];
+            ValidateDecimalScale(scale);
+            uint unsignedMantissa = NetworkOrderDeserializer.ReadUInt32(span.Slice(1));
+            var data = new DecimalData(((uint)(scale << 16)) | unsignedMantissa & 0x80000000, 0, unsignedMantissa & 0x7FFFFFFF, 0);
+            return Unsafe.As<DecimalData, decimal>(ref data);
+        }
+
+        private static void ValidateDecimalScale(byte scale)
+        {
             if (scale > 28)
             {
                 throw new SyntaxErrorException($"Unrepresentable AMQP decimal table field: scale={scale}");
             }
-
-            uint unsignedMantissa = NetworkOrderDeserializer.ReadUInt32(span.Slice(1));
-            return new decimal(
-                // The low 32 bits of a 96-bit integer
-                lo: (int)(unsignedMantissa & 0x7FFFFFFF),
-                // The middle 32 bits of a 96-bit integer.
-                mid: 0,
-                // The high 32 bits of a 96-bit integer.
-                hi: 0,
-                isNegative: (unsignedMantissa & 0x80000000) != 0,
-                // A power of 10 ranging from 0 to 28.
-                scale: scale);
         }
 
         public static IList ReadArray(ReadOnlySpan<byte> span, out int bytesRead)
@@ -229,16 +253,16 @@ public static int ReadBits(ReadOnlySpan<byte> span,
             out bool val11, out bool val12, out bool val13, out bool val14)
         {
             byte bits = span[0];
-            val1  = (bits & 0b1000_0000) != 0;
-            val2  = (bits & 0b0100_0000) != 0;
-            val3  = (bits & 0b0010_0000) != 0;
-            val4  = (bits & 0b0001_0000) != 0;
-            val5  = (bits & 0b0000_1000) != 0;
-            val6  = (bits & 0b0000_0100) != 0;
-            val7  = (bits & 0b0000_0010) != 0;
-            val8  = (bits & 0b0000_0001) != 0;
+            val1 = (bits & 0b1000_0000) != 0;
+            val2 = (bits & 0b0100_0000) != 0;
+            val3 = (bits & 0b0010_0000) != 0;
+            val4 = (bits & 0b0001_0000) != 0;
+            val5 = (bits & 0b0000_1000) != 0;
+            val6 = (bits & 0b0000_0100) != 0;
+            val7 = (bits & 0b0000_0010) != 0;
+            val8 = (bits & 0b0000_0001) != 0;
             bits = span[1];
-            val9  = (bits & 0b1000_0000) != 0;
+            val9 = (bits & 0b1000_0000) != 0;
             val10 = (bits & 0b0100_0000) != 0;
             val11 = (bits & 0b0010_0000) != 0;
             val12 = (bits & 0b0001_0000) != 0;
@@ -342,15 +366,11 @@ public static int GetArrayByteCount(IList val)
             return byteCount;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int WriteDecimal(Span<byte> span, decimal value)
         {
-            DecimalToAmqp(value, out byte scale, out int mantissa);
-            span[0] = scale;
-            return 1 + WriteLong(span.Slice(1), (uint)mantissa);
-        }
-
-        private static void DecimalToAmqp(decimal value, out byte scale, out int mantissa)
-        {
+            // Cast the decimal to our struct to avoid the decimal.GetBits allocations.
+            DecimalData data = Unsafe.As<decimal, DecimalData>(ref value);
             // According to the documentation :-
             //  - word 0: low-order "mantissa"
             //  - word 1, word 2: medium- and high-order "mantissa"
@@ -360,16 +380,16 @@ private static void DecimalToAmqp(decimal value, out byte scale, out int mantiss
             // We need to be careful about the range of word 0, too: we can
             // only take 31 bits worth of it, since the sign bit needs to
             // fit in there too.
-            int[] bitRepresentation = decimal.GetBits(value);
-            if (bitRepresentation[1] != 0 || // mantissa extends into middle word
-                bitRepresentation[2] != 0 || // mantissa extends into top word
-                bitRepresentation[0] < 0) // mantissa extends beyond 31 bits
+            if (data.Mid != 0 || // mantissa extends into middle word
+                data.Hi != 0 || // mantissa extends into top word
+                data.Lo < 0) // mantissa extends beyond 31 bits
             {
-                throw new WireFormattingException("Decimal overflow in AMQP encoding", value);
+                return ThrowWireFormattingException(value);
             }
-            scale = (byte)((((uint)bitRepresentation[3]) >> 16) & 0xFF);
-            mantissa = (int)((((uint)bitRepresentation[3]) & 0x80000000) |
-                             (((uint)bitRepresentation[0]) & 0x7FFFFFFF));
+
+            span[0] = (byte)((data.Flags >> 16) & 0xFF);
+            WriteLong(span.Slice(1), (data.Flags & 0b1000_0000_0000_0000_0000_0000_0000_0000) | (data.Lo & 0b0111_1111_1111_1111_1111_1111_1111_1111));
+            return 5;
         }
 
         public static int WriteFieldValue(Span<byte> span, object value)
@@ -499,7 +519,7 @@ public static int WriteLonglong(Span<byte> span, ulong val)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int WriteBits(Span<byte> span, bool val)
         {
-            span[0] = val ? (byte) 1 : (byte) 0;
+            span[0] = val ? (byte)1 : (byte)0;
             return 1;
         }
 
@@ -855,5 +875,10 @@ public static int ThrowSyntaxErrorException(uint byteCount)
         {
             throw new SyntaxErrorException($"Long string too long; byte length={byteCount}, max={int.MaxValue}");
         }
+
+        private static int ThrowWireFormattingException(decimal value)
+        {
+            throw new WireFormattingException("Decimal overflow in AMQP encoding", value);
+        }
     }
 }