Add Code

Author: YarinOmesi

csharp/src/Google.Protobuf/Collections/RepeatedField.cs

@@ -8,11 +8,13 @@
 #endregion
 
 using System;
+using System.Buffers;
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Security;
 #if NET5_0_OR_GREATER
 using System.Runtime.CompilerServices;
@@ -116,12 +118,31 @@ public void AddEntriesFrom(ref ParseContext ctx, FieldCodec<T> codec)
                     {
                         EnsureSize(count + (length / codec.FixedSize));
 
-                        while (!SegmentedBufferHelper.IsReachedLimit(ref ctx.state))
+
+                        // if little endian try to copy packed buffer into RepeatedField array
+                        if(BitConverter.IsLittleEndian)
+                        {
+                            unsafe
+                            {
+                                GCHandle gcHandle = GCHandle.Alloc(array, GCHandleType.Pinned);
+                                IntPtr addr = gcHandle.AddrOfPinnedObject();
+                                Span<byte> span = new Span<byte>(addr.ToPointer(), array.Length * codec.FixedSize)
+                                    .Slice(count * codec.FixedSize);
+                                Debug.Assert(span.Length >= length);
+                                ParsingPrimitives.ReadPackedFieldLittleEndian(ref ctx.buffer, ref ctx.state, length, span);
+                                count += length / codec.FixedSize;
+                                gcHandle.Free();
+                            }
+                        }
+                        else
                         {
-                            // Only FieldCodecs with a fixed size can reach here, and they are all known
-                            // types that don't allow the user to specify a custom reader action.
-                            // reader action will never return null.
-                            array[count++] = reader(ref ctx);
+                            while (!SegmentedBufferHelper.IsReachedLimit(ref ctx.state))
+                            {
+                                // Only FieldCodecs with a fixed size can reach here, and they are all known
+                                // types that don't allow the user to specify a custom reader action.
+                                // reader action will never return null.
+                                array[count++] = reader(ref ctx);
+                            }
                         }
                     }
                     else

csharp/src/Google.Protobuf/ParsingPrimitives.cs

@@ -11,6 +11,7 @@
 using System.Buffers;
 using System.Buffers.Binary;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -45,7 +46,7 @@ public static int ParseLength(ref ReadOnlySpan<byte> buffer, ref ParserInternalS
 
         /// <summary>
         /// Parses the next tag.
-        /// If the end of logical stream was reached, an invalid tag of 0 is returned. 
+        /// If the end of logical stream was reached, an invalid tag of 0 is returned.
         /// </summary>
         public static uint ParseTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
         {
@@ -382,7 +383,7 @@ public static float ParseFloat(ref ReadOnlySpan<byte> buffer, ref ParserInternal
             // ReadUnaligned uses processor architecture for endianness.
             float result = Unsafe.ReadUnaligned<float>(ref MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, length)));
             state.bufferPos += length;
-            return result;  
+            return result;
         }
 
         private static unsafe float ParseFloatSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
@@ -737,7 +738,7 @@ public static uint ReadRawVarint32(Stream input)
         /// </summary>
         /// <remarks>
         /// ZigZag encodes signed integers into values that can be efficiently
-        /// encoded with varint.  (Otherwise, negative values must be 
+        /// encoded with varint.  (Otherwise, negative values must be
         /// sign-extended to 32 bits to be varint encoded, thus always taking
         /// 5 bytes on the wire.)
         /// </remarks>
@@ -751,7 +752,7 @@ public static int DecodeZigZag32(uint n)
         /// </summary>
         /// <remarks>
         /// ZigZag encodes signed integers into values that can be efficiently
-        /// encoded with varint.  (Otherwise, negative values must be 
+        /// encoded with varint.  (Otherwise, negative values must be
         /// sign-extended to 64 bits to be varint encoded, thus always taking
         /// 10 bytes on the wire.)
         /// </remarks>
@@ -810,5 +811,25 @@ private static void ReadRawBytesIntoSpan(ref ReadOnlySpan<byte> buffer, ref Pars
                 state.bufferPos += unreadSpan.Length;
             }
         }
+
+        /// <summary>
+        /// Read LittleEndian packed field from buffer of specified length into a span.
+        /// The amount of data available and the current limit should be checked before calling this method.
+        /// </summary>
+        internal static void ReadPackedFieldLittleEndian(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length, Span<byte> outBuffer)
+        {
+            Debug.Assert(BitConverter.IsLittleEndian);
+
+            if (length <= state.bufferSize - state.bufferPos)
+            {
+                buffer.Slice(state.bufferPos, length).CopyTo(outBuffer);
+                state.bufferPos += length;
+            }
+            else
+            {
+                ReadRawBytesIntoSpan(ref buffer, ref state, length, outBuffer);
+            }
+        }
+
     }
 }