Merge pull request #753 from Anarh2404/improvements

michaelklishin · web-flow · commit f5318decf7ad · 2020-03-09T14:51:48.000+03:00
Allocation improvements
diff --git a/projects/client/Apigen/src/apigen/Apigen.cs b/projects/client/Apigen/src/apigen/Apigen.cs
@@ -637,7 +637,7 @@ public void EmitClassProperties(AmqpClass c)
             EmitLine($"    public override ushort ProtocolClassId => {c.Index};");
             EmitLine($"    public override string ProtocolClassName => \"{c.Name}\";");
             EmitLine("");
-            EmitLine("    internal override void ReadPropertiesFrom(Client.Impl.ContentHeaderPropertyReader reader)");
+            EmitLine("    internal override void ReadPropertiesFrom(ref Client.Impl.ContentHeaderPropertyReader reader)");
             EmitLine("    {");
             foreach (AmqpField f in c.m_Fields)
             {
@@ -660,7 +660,7 @@ public void EmitClassProperties(AmqpClass c)
             }
             EmitLine("    }");
             EmitLine("");
-            EmitLine("    internal override void WritePropertiesTo(Client.Impl.ContentHeaderPropertyWriter writer)");
+            EmitLine("    internal override void WritePropertiesTo(ref Client.Impl.ContentHeaderPropertyWriter writer)");
             EmitLine("    {");
             foreach (AmqpField f in c.m_Fields)
             {
@@ -841,15 +841,15 @@ public void EmitClassMethodImplementations(AmqpClass c)
                 EmitLine($"    public override string ProtocolMethodName => \"{c.Name}.{m.Name}\";");
                 EmitLine($"    public override bool HasContent => {(m.HasContent ? "true" : "false")};");
                 EmitLine("");
-                EmitLine("    public override void ReadArgumentsFrom(Client.Impl.MethodArgumentReader reader)");
+                EmitLine("    public override void ReadArgumentsFrom(ref Client.Impl.MethodArgumentReader reader)");
                 EmitLine("    {");
                 foreach (AmqpField f in m.m_Fields)
                 {
                     EmitLine($"      _{MangleMethod(f.Name)} = reader.Read{MangleClass(ResolveDomain(f.Domain))}();");
                 }
                 EmitLine("    }");
                 EmitLine("");
-                EmitLine("    public override void WriteArgumentsTo(Client.Impl.MethodArgumentWriter writer)");
+                EmitLine("    public override void WriteArgumentsTo(ref Client.Impl.MethodArgumentWriter writer)");
                 EmitLine("    {");
                 foreach (AmqpField f in m.m_Fields)
                 {
@@ -936,7 +936,8 @@ public void EmitMethodArgumentReader()
             EmitLine("      Client.Impl.MethodBase result = DecodeMethodFrom(classId, methodId);");
             EmitLine("      if(result != null)");
             EmitLine("      {");
-            EmitLine("        result.ReadArgumentsFrom(new Client.Impl.MethodArgumentReader(memory.Slice(4)));");
+            EmitLine("        Client.Impl.MethodArgumentReader reader = new Client.Impl.MethodArgumentReader(memory.Slice(4));");
+            EmitLine("        result.ReadArgumentsFrom(ref reader);");
             EmitLine("        return result;");
             EmitLine("      }");
             EmitLine("");
diff --git a/projects/client/RabbitMQ.Client/src/client/impl/ContentHeaderBase.cs b/projects/client/RabbitMQ.Client/src/client/impl/ContentHeaderBase.cs
@@ -71,12 +71,13 @@ internal ulong ReadFrom(ReadOnlyMemory<byte> memory)
         {
             // Skipping the first two bytes since they arent used (weight - not currently used)
             ulong bodySize = NetworkOrderDeserializer.ReadUInt64(memory.Slice(2));
-            ReadPropertiesFrom(new ContentHeaderPropertyReader(memory.Slice(10)));
+            ContentHeaderPropertyReader reader = new ContentHeaderPropertyReader(memory.Slice(10));
+            ReadPropertiesFrom(ref reader);
             return bodySize;
         }
 
-        internal abstract void ReadPropertiesFrom(ContentHeaderPropertyReader reader);
-        internal abstract void WritePropertiesTo(ContentHeaderPropertyWriter writer);
+        internal abstract void ReadPropertiesFrom(ref ContentHeaderPropertyReader reader);
+        internal abstract void WritePropertiesTo(ref ContentHeaderPropertyWriter writer);
 
         private const ushort ZERO = 0;
 
@@ -86,7 +87,7 @@ internal int WriteTo(Memory<byte> memory, ulong bodySize)
             NetworkOrderSerializer.WriteUInt64(memory.Slice(2), bodySize);
 
             ContentHeaderPropertyWriter writer = new ContentHeaderPropertyWriter(memory.Slice(10));
-            WritePropertiesTo(writer);
+            WritePropertiesTo(ref writer);
             return 10 + writer.Offset;
         }
         public int GetRequiredBufferSize()
diff --git a/projects/client/RabbitMQ.Client/src/client/impl/ContentHeaderPropertyReader.cs b/projects/client/RabbitMQ.Client/src/client/impl/ContentHeaderPropertyReader.cs
@@ -45,16 +45,17 @@
 
 namespace RabbitMQ.Client.Impl
 {
-    class ContentHeaderPropertyReader
+    struct ContentHeaderPropertyReader
     {
-        protected ushort m_bitCount;
-        protected ushort m_flagWord;
-        private int _memoryOffset = 0;
+        private ushort m_bitCount;
+        private ushort m_flagWord;
+        private int _memoryOffset;
         private readonly ReadOnlyMemory<byte> _memory;
 
         public ContentHeaderPropertyReader(ReadOnlyMemory<byte> memory)
         {
             _memory = memory;
+            _memoryOffset = 0;
             m_flagWord = 1; // just the continuation bit
             m_bitCount = 15; // the correct position to force a m_flagWord read
         }
diff --git a/projects/client/RabbitMQ.Client/src/client/impl/ContentHeaderPropertyWriter.cs b/projects/client/RabbitMQ.Client/src/client/impl/ContentHeaderPropertyWriter.cs
@@ -45,18 +45,19 @@
 
 namespace RabbitMQ.Client.Impl
 {
-    class ContentHeaderPropertyWriter
+    struct ContentHeaderPropertyWriter
     {
-        protected int m_bitCount;
-        protected ushort m_flagWord;
-        public int Offset { get; private set; } = 0;
+        private int _bitCount;
+        private ushort _flagWord;
+        public int Offset { get; private set; }
         public Memory<byte> Memory { get; private set; }
 
         public ContentHeaderPropertyWriter(Memory<byte> memory)
         {
             Memory = memory;
-            m_flagWord = 0;
-            m_bitCount = 0;
+            _flagWord = 0;
+            _bitCount = 0;
+            Offset = 0;
         }
 
         public void FinishPresence()
@@ -91,17 +92,17 @@ public void WriteOctet(byte val)
 
         public void WritePresence(bool present)
         {
-            if (m_bitCount == 15)
+            if (_bitCount == 15)
             {
                 EmitFlagWord(true);
             }
 
             if (present)
             {
-                int bit = 15 - m_bitCount;
-                m_flagWord = (ushort)(m_flagWord | (1 << bit));
+                int bit = 15 - _bitCount;
+                _flagWord = (ushort)(_flagWord | (1 << bit));
             }
-            m_bitCount++;
+            _bitCount++;
         }
 
         public void WriteShort(ushort val)
@@ -126,10 +127,10 @@ public void WriteTimestamp(AmqpTimestamp val)
 
         private void EmitFlagWord(bool continuationBit)
         {
-            NetworkOrderSerializer.WriteUInt16(Memory.Slice(Offset), (ushort)(continuationBit ? (m_flagWord | 1) : m_flagWord));
+            NetworkOrderSerializer.WriteUInt16(Memory.Slice(Offset), (ushort)(continuationBit ? (_flagWord | 1) : _flagWord));
             Offset += 2;
-            m_flagWord = 0;
-            m_bitCount = 0;
+            _flagWord = 0;
+            _bitCount = 0;
         }
     }
 }
diff --git a/projects/client/RabbitMQ.Client/src/client/impl/Frame.cs b/projects/client/RabbitMQ.Client/src/client/impl/Frame.cs
@@ -117,7 +117,7 @@ internal override int WritePayload(Memory<byte> memory)
             NetworkOrderSerializer.WriteUInt16(memory, _method.ProtocolClassId);
             NetworkOrderSerializer.WriteUInt16(memory.Slice(2), _method.ProtocolMethodId);
             var argWriter = new MethodArgumentWriter(memory.Slice(4));
-            _method.WriteArgumentsTo(argWriter);
+            _method.WriteArgumentsTo(ref argWriter);
             argWriter.Flush();
             return 4 + argWriter.Offset;
         }
diff --git a/projects/client/RabbitMQ.Client/src/client/impl/MethodArgumentReader.cs b/projects/client/RabbitMQ.Client/src/client/impl/MethodArgumentReader.cs
@@ -45,7 +45,7 @@
 
 namespace RabbitMQ.Client.Impl
 {
-    class MethodArgumentReader
+    struct MethodArgumentReader
     {
         private int? _bit;
         private int _bits;
@@ -54,7 +54,8 @@ public MethodArgumentReader(ReadOnlyMemory<byte> memory)
         {
             _memory = memory;
             _memoryOffset = 0;
-            ClearBits();
+            _bits = 0;
+            _bit = null;
         }
 
         private readonly ReadOnlyMemory<byte> _memory;
diff --git a/projects/client/RabbitMQ.Client/src/client/impl/MethodArgumentWriter.cs b/projects/client/RabbitMQ.Client/src/client/impl/MethodArgumentWriter.cs
@@ -44,18 +44,21 @@
 
 namespace RabbitMQ.Client.Impl
 {
-    class MethodArgumentWriter
+    struct MethodArgumentWriter
     {
         private byte _bitAccumulator;
         private int _bitMask;
         private bool _needBitFlush;
-        public int Offset { get; private set; } = 0;
+        public int Offset { get; private set; }
         public Memory<byte> Memory { get; private set; }
 
         public MethodArgumentWriter(Memory<byte> memory)
         {
             Memory = memory;
-            ResetBitAccumulator();
+            _needBitFlush = false;
+            _bitAccumulator = 0;
+            _bitMask = 1;
+            Offset = 0;
         }
 
         public void Flush()
diff --git a/projects/client/RabbitMQ.Client/src/client/impl/MethodBase.cs b/projects/client/RabbitMQ.Client/src/client/impl/MethodBase.cs
@@ -62,8 +62,8 @@ abstract class MethodBase : IMethod
         public abstract string ProtocolMethodName { get; }
 
         public abstract void AppendArgumentDebugStringTo(StringBuilder stringBuilder);
-        public abstract void ReadArgumentsFrom(MethodArgumentReader reader);
-        public abstract void WriteArgumentsTo(MethodArgumentWriter writer);
+        public abstract void ReadArgumentsFrom(ref MethodArgumentReader reader);
+        public abstract void WriteArgumentsTo(ref MethodArgumentWriter writer);
         public abstract int GetRequiredBufferSize();
     }
 }
diff --git a/projects/client/Unit/src/unit/TestBasicProperties.cs b/projects/client/Unit/src/unit/TestBasicProperties.cs
@@ -106,12 +106,12 @@ public void TestNullableProperties_CanWrite(
             Assert.AreEqual(isMessageIdPresent, subject.IsMessageIdPresent());
 
             var writer = new Impl.ContentHeaderPropertyWriter(new byte[1024]);
-            subject.WritePropertiesTo(writer);
+            subject.WritePropertiesTo(ref writer);
 
             // Read from Stream
             var propertiesFromStream = new Framing.BasicProperties();
             var reader = new Impl.ContentHeaderPropertyReader(writer.Memory.Slice(0, writer.Offset));
-            propertiesFromStream.ReadPropertiesFrom(reader);
+            propertiesFromStream.ReadPropertiesFrom(ref reader);
 
             Assert.AreEqual(clusterId, propertiesFromStream.ClusterId);
             Assert.AreEqual(correlationId, propertiesFromStream.CorrelationId);

Original file line number	Diff line number	Diff line change
`@@ -45,16 +45,17 @@`
`45`	`45`
`46`	`46`	`namespace RabbitMQ.Client.Impl`
`47`	`47`	`{`
`48`		`- class ContentHeaderPropertyReader`
	`48`	`+ struct ContentHeaderPropertyReader`
`49`	`49`	`{`
`50`		`- protected ushort m_bitCount;`
`51`		`- protected ushort m_flagWord;`
`52`		`- private int _memoryOffset = 0;`
	`50`	`+ private ushort m_bitCount;`
	`51`	`+ private ushort m_flagWord;`
	`52`	`+ private int _memoryOffset;`
`53`	`53`	`private readonly ReadOnlyMemory<byte> _memory;`
`54`	`54`
`55`	`55`	`public ContentHeaderPropertyReader(ReadOnlyMemory<byte> memory)`
`56`	`56`	`{`
`57`	`57`	`_memory = memory;`
	`58`	`+ _memoryOffset = 0;`
`58`	`59`	`m_flagWord = 1; // just the continuation bit`
`59`	`60`	`m_bitCount = 15; // the correct position to force a m_flagWord read`
`60`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,18 +45,19 @@`
`45`	`45`
`46`	`46`	`namespace RabbitMQ.Client.Impl`
`47`	`47`	`{`
`48`		`- class ContentHeaderPropertyWriter`
	`48`	`+ struct ContentHeaderPropertyWriter`
`49`	`49`	`{`
`50`		`- protected int m_bitCount;`
`51`		`- protected ushort m_flagWord;`
`52`		`- public int Offset { get; private set; } = 0;`
	`50`	`+ private int _bitCount;`
	`51`	`+ private ushort _flagWord;`
	`52`	`+ public int Offset { get; private set; }`
`53`	`53`	`public Memory<byte> Memory { get; private set; }`
`54`	`54`
`55`	`55`	`public ContentHeaderPropertyWriter(Memory<byte> memory)`
`56`	`56`	`{`
`57`	`57`	`Memory = memory;`
`58`		`- m_flagWord = 0;`
`59`		`- m_bitCount = 0;`
	`58`	`+ _flagWord = 0;`
	`59`	`+ _bitCount = 0;`
	`60`	`+ Offset = 0;`
`60`	`61`	`}`
`61`	`62`
`62`	`63`	`public void FinishPresence()`
`@@ -91,17 +92,17 @@ public void WriteOctet(byte val)`
`91`	`92`
`92`	`93`	`public void WritePresence(bool present)`
`93`	`94`	`{`
`94`		`- if (m_bitCount == 15)`
	`95`	`+ if (_bitCount == 15)`
`95`	`96`	`{`
`96`	`97`	`EmitFlagWord(true);`
`97`	`98`	`}`
`98`	`99`
`99`	`100`	`if (present)`
`100`	`101`	`{`
`101`		`- int bit = 15 - m_bitCount;`
`102`		`- m_flagWord = (ushort)(m_flagWord \| (1 << bit));`
	`102`	`+ int bit = 15 - _bitCount;`
	`103`	`+ _flagWord = (ushort)(_flagWord \| (1 << bit));`
`103`	`104`	`}`
`104`		`- m_bitCount++;`
	`105`	`+ _bitCount++;`
`105`	`106`	`}`
`106`	`107`
`107`	`108`	`public void WriteShort(ushort val)`
`@@ -126,10 +127,10 @@ public void WriteTimestamp(AmqpTimestamp val)`
`126`	`127`
`127`	`128`	`private void EmitFlagWord(bool continuationBit)`
`128`	`129`	`{`
`129`		`- NetworkOrderSerializer.WriteUInt16(Memory.Slice(Offset), (ushort)(continuationBit ? (m_flagWord \| 1) : m_flagWord));`
	`130`	`+ NetworkOrderSerializer.WriteUInt16(Memory.Slice(Offset), (ushort)(continuationBit ? (_flagWord \| 1) : _flagWord));`
`130`	`131`	`Offset += 2;`
`131`		`- m_flagWord = 0;`
`132`		`- m_bitCount = 0;`
	`132`	`+ _flagWord = 0;`
	`133`	`+ _bitCount = 0;`
`133`	`134`	`}`
`134`	`135`	`}`
`135`	`136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ internal override int WritePayload(Memory<byte> memory)`
`117`	`117`	`NetworkOrderSerializer.WriteUInt16(memory, _method.ProtocolClassId);`
`118`	`118`	`NetworkOrderSerializer.WriteUInt16(memory.Slice(2), _method.ProtocolMethodId);`
`119`	`119`	`var argWriter = new MethodArgumentWriter(memory.Slice(4));`
`120`		`- _method.WriteArgumentsTo(argWriter);`
	`120`	`+ _method.WriteArgumentsTo(ref argWriter);`
`121`	`121`	`argWriter.Flush();`
`122`	`122`	`return 4 + argWriter.Offset;`
`123`	`123`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@`
`45`	`45`
`46`	`46`	`namespace RabbitMQ.Client.Impl`
`47`	`47`	`{`
`48`		`- class MethodArgumentReader`
	`48`	`+ struct MethodArgumentReader`
`49`	`49`	`{`
`50`	`50`	`private int? _bit;`
`51`	`51`	`private int _bits;`
`@@ -54,7 +54,8 @@ public MethodArgumentReader(ReadOnlyMemory<byte> memory)`
`54`	`54`	`{`
`55`	`55`	`_memory = memory;`
`56`	`56`	`_memoryOffset = 0;`
`57`		`- ClearBits();`
	`57`	`+ _bits = 0;`
	`58`	`+ _bit = null;`
`58`	`59`	`}`
`59`	`60`
`60`	`61`	`private readonly ReadOnlyMemory<byte> _memory;`
Original file line number	Diff line number	Diff line change
`@@ -44,18 +44,21 @@`
`44`	`44`
`45`	`45`	`namespace RabbitMQ.Client.Impl`
`46`	`46`	`{`
`47`		`- class MethodArgumentWriter`
	`47`	`+ struct MethodArgumentWriter`
`48`	`48`	`{`
`49`	`49`	`private byte _bitAccumulator;`
`50`	`50`	`private int _bitMask;`
`51`	`51`	`private bool _needBitFlush;`
`52`		`- public int Offset { get; private set; } = 0;`
	`52`	`+ public int Offset { get; private set; }`
`53`	`53`	`public Memory<byte> Memory { get; private set; }`
`54`	`54`
`55`	`55`	`public MethodArgumentWriter(Memory<byte> memory)`
`56`	`56`	`{`
`57`	`57`	`Memory = memory;`
`58`		`- ResetBitAccumulator();`
	`58`	`+ _needBitFlush = false;`
	`59`	`+ _bitAccumulator = 0;`
	`60`	`+ _bitMask = 1;`
	`61`	`+ Offset = 0;`
`59`	`62`	`}`
`60`	`63`
`61`	`64`	`public void Flush()`
Original file line number	Diff line number	Diff line change
`@@ -62,8 +62,8 @@ abstract class MethodBase : IMethod`
`62`	`62`	`public abstract string ProtocolMethodName { get; }`
`63`	`63`
`64`	`64`	`public abstract void AppendArgumentDebugStringTo(StringBuilder stringBuilder);`
`65`		`- public abstract void ReadArgumentsFrom(MethodArgumentReader reader);`
`66`		`- public abstract void WriteArgumentsTo(MethodArgumentWriter writer);`
	`65`	`+ public abstract void ReadArgumentsFrom(ref MethodArgumentReader reader);`
	`66`	`+ public abstract void WriteArgumentsTo(ref MethodArgumentWriter writer);`
`67`	`67`	`public abstract int GetRequiredBufferSize();`
`68`	`68`	`}`
`69`	`69`	`}`