Merge pull request #91 from paulpach/lockless

Lockless doubles

Author: TwoTenPvP

MLAPI.Tests/NetworkingManagerComponents/Binary/BitStreamTest.cs

@@ -330,6 +330,21 @@ public void TestWriteDouble()
 
         }
 
+        [Test]
+        public void TestWriteDoublePacked()
+        {
+            double somenumber = Math.PI;
+            BitStream outStream = new BitStream();
+
+            outStream.WriteDoublePacked(somenumber);
+            byte[] buffer = outStream.GetBuffer();
+
+            BitStream inStream = new BitStream(buffer);
+
+            Assert.That(inStream.ReadDoublePacked(), Is.EqualTo(somenumber));
+
+        }
+
         [Test]
         public void TestWriteMisaligned()
         {

MLAPI/NetworkingManagerComponents/Binary/BitStream.cs

@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using System.Runtime.InteropServices;
+using System.Security;
 using UnityEngine;
 using static MLAPI.NetworkingManagerComponents.Binary.Arithmetic;
 
@@ -10,13 +12,27 @@ namespace MLAPI.NetworkingManagerComponents.Binary
     /// </summary>
     public sealed class BitStream : Stream
     {
+
+        [StructLayout(LayoutKind.Explicit)]
+        internal struct UIntFloat
+        {
+            [FieldOffset(0)]
+            public float floatValue;
+
+            [FieldOffset(0)]
+            public uint intValue;
+
+            [FieldOffset(0)]
+            public double doubleValue;
+
+            [FieldOffset(0)]
+            public ulong longValue;
+        }
+
+
         const int initialCapacity = 16;
         const float initialGrowthFactor = 2.0f;
         private byte[] target;
-        private static readonly float[] holder_f = new float[1];
-        private static readonly double[] holder_d = new double[1];
-        private static readonly uint[] holder_i = new uint[1];
-        private static readonly ulong[] holder_l = new ulong[1];
 
         /// <summary>
         /// A stream that supports writing data smaller than a single byte. This stream also has a built-in compression algorithm that can (optionally) be used to write compressed data.
@@ -285,13 +301,10 @@ public void WriteBit(bool bit)
         /// <param name="value">Value to write</param>
         public void WriteSingle(float value)
         {
-            lock (holder_f)
-                lock (holder_i)
-                {
-                    holder_f[0] = value;
-                    Buffer.BlockCopy(holder_f, 0, holder_i, 0, 4);
-                    WriteUInt32(holder_i[0]);
-                }
+            UIntFloat conversion = new UIntFloat();
+            conversion.floatValue = value;
+            uint binary = conversion.intValue;
+            WriteUInt32(binary);
         }
 
         /// <summary>
@@ -300,13 +313,11 @@ public void WriteSingle(float value)
         /// <param name="value">Value to write</param>
         public void WriteDouble(double value)
         {
-            lock (holder_d)
-                lock (holder_l)
-                {
-                    holder_d[0] = value;
-                    Buffer.BlockCopy(holder_d, 0, holder_l, 0, 8);
-                    WriteUInt64(holder_l[0]);
-                }
+            UIntFloat conversion = new UIntFloat();
+            conversion.doubleValue = value;
+            ulong binary = conversion.longValue;
+            WriteUInt64(binary);
+
         }
 
         /// <summary>
@@ -315,13 +326,10 @@ public void WriteDouble(double value)
         /// <param name="value">Value to write</param>
         public void WriteSinglePacked(float value)
         {
-            lock (holder_f)
-                lock (holder_i)
-                {
-                    holder_f[0] = value;
-                    Buffer.BlockCopy(holder_f, 0, holder_i, 0, 4);
-                    WriteUInt32Packed(BinaryHelpers.SwapEndian(holder_i[0]));
-                }
+            UIntFloat conversion = new UIntFloat();
+            conversion.floatValue = value;
+            uint binary = conversion.intValue;
+            WriteUInt32Packed(binary);
         }
 
         /// <summary>
@@ -330,13 +338,11 @@ public void WriteSinglePacked(float value)
         /// <param name="value">Value to write</param>
         public void WriteDoublePacked(double value)
         {
-            lock (holder_d)
-                lock (holder_l)
-                {
-                    holder_d[0] = value;
-                    Buffer.BlockCopy(holder_d, 0, holder_l, 0, 8);
-                    WriteUInt64Packed(BinaryHelpers.SwapEndian(holder_l[0]));
-                }
+            UIntFloat conversion = new UIntFloat();
+            conversion.doubleValue = value;
+            ulong binary = conversion.longValue;
+
+            WriteUInt64Packed(binary);
         }
 
         /// <summary>
@@ -516,13 +522,10 @@ public void WriteRotation(Quaternion rotation, int bytesPerAngle)
         public float ReadSingle()
         {
             uint read = ReadUInt32();
-            lock (holder_f)
-                lock (holder_i)
-                {
-                    holder_i[0] = read;
-                    Buffer.BlockCopy(holder_i, 0, holder_f, 0, 4);
-                    return holder_f[0];
-                }
+
+            UIntFloat conversion = new UIntFloat();
+            conversion.intValue = read;
+            return conversion.floatValue;
         }
 
 
@@ -533,14 +536,12 @@ public float ReadSingle()
         public double ReadDouble()
         {
             ulong read = ReadUInt64();
-            lock (holder_d)
-                lock (holder_l)
-                {
-                    holder_l[0] = read;
-                    Buffer.BlockCopy(holder_l, 0, holder_d, 0, 8);
-                    return holder_d[0];
-                }
+
+            UIntFloat conversion = new UIntFloat();
+            conversion.longValue = read;
+            return conversion.doubleValue;
         }
+    
 
         /// <summary>
         /// Read a single-precision floating point value from the stream from a varint
@@ -549,13 +550,9 @@ public double ReadDouble()
         public float ReadSinglePacked()
         {
             uint read = ReadUInt32Packed();
-            lock (holder_f)
-                lock (holder_i)
-                {
-                    holder_i[0] = BinaryHelpers.SwapEndian(read);
-                    Buffer.BlockCopy(holder_i, 0, holder_f, 0, 4);
-                    return holder_f[0];
-                }
+            UIntFloat conversion = new UIntFloat();
+            conversion.intValue = read;
+            return conversion.floatValue;
         }
 
         /// <summary>
@@ -565,13 +562,9 @@ public float ReadSinglePacked()
         public double ReadDoublePacked()
         {
             ulong read = ReadUInt64Packed();
-            lock (holder_d)
-                lock (holder_l)
-                {
-                    holder_l[0] = BinaryHelpers.SwapEndian(read);
-                    Buffer.BlockCopy(holder_l, 0, holder_d, 0, 8);
-                    return holder_d[0];
-                }
+            UIntFloat conversion = new UIntFloat();
+            conversion.longValue = read;
+            return conversion.doubleValue;
         }
 
         /// <summary>