Reduce memory allocation

Author: manuelbl

QrCodeGenerator/SegmentCompaction.cs

@@ -7,6 +7,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Net.Codecrete.QrCodeGenerator
@@ -43,97 +44,114 @@ internal static List<DataSegment> BuildSegments(ArraySegment<byte> bytes, int ve
             // The algorithm first determines the best encoding mode for each byte
             // and builds blocks of bytes with the same encoding mode.
             var blocks = BuildBlocks(bytes, considerKanjiMode);
+            var blockCount = blocks.Length;
 
             // Since switching from one mode to another and back requires additional bits,
             // the additional cost of switching can be higher than the savings
             // from using a more efficient mode. If this is the case, two or three blocks are merged.
             // In the first step, short numeric blocks are merged with alphanumeric blocks.
             // In the second step, all types of blocks are merged into byte blocks.
-            MergeBlocks(blocks, version, DataSegmentMode.Alphanumeric,
+            blockCount = MergeBlocks(blocks, blockCount, version, DataSegmentMode.Alphanumeric,
                 (mode0, mode1, mode2) => mode0 == DataSegmentMode.Alphanumeric
                                          && mode1 == DataSegmentMode.Numeric && mode2 == mode0,
                 (mode0, mode1) => (mode0 == DataSegmentMode.Alphanumeric && mode1 == DataSegmentMode.Numeric)
                                   || (mode0 == DataSegmentMode.Numeric && mode1 == DataSegmentMode.Alphanumeric)
             );
-            MergeBlocks(blocks, version, DataSegmentMode.Binary,
+            blockCount = MergeBlocks(blocks, blockCount, version, DataSegmentMode.Binary,
                 (mode0, mode1, mode2) => mode1 != DataSegmentMode.Binary && mode2 == mode0,
                 (mode0, mode1) => (mode0 == DataSegmentMode.Binary && mode1 != DataSegmentMode.Binary)
                                   || (mode0 != DataSegmentMode.Binary && mode1 == DataSegmentMode.Binary)
             );
 
+            var segments = new List<DataSegment>(blockCount);
             var offset = 0;
-            return blocks.ConvertAll(block =>
+            for (var i = 0; i < blockCount; i += 1)
             {
+                var block = blocks[i];
                 var blockBytes = bytes.MakeSlice(offset, block.Length);
                 offset += block.Length;
-                return DataSegment.MakeSegment(block.Mode, blockBytes);
-            });
+                segments.Add(DataSegment.MakeSegment(block.Mode, blockBytes));
+            }
+
+            return segments;
         }
 
         /// <summary>
         /// Merges blocks if the length can be reduced.
         /// </summary>
-        /// <param name="blocks">The list of blocks to process.</param>
+        /// <param name="blocks">The array of blocks to process.</param>
+        /// <param name="blockCount">The number of active blocks in the array.</param>
         /// <param name="version">The QR code version.</param>
         /// <param name="mergedMode">The data segment mode of the merged block.</param>
         /// <param name="merge3Condition">Condition for testing 3 consecutive blocks.</param>
         /// <param name="merge2Condition">Condition for testing 2 consecutive blocks.</param>
+        /// <returns>Number of remaining blocks in array</returns>
         [SuppressMessage("csharpsquid", "S3776")]
-        private static void MergeBlocks(List<Block> blocks, int version, DataSegmentMode mergedMode,
+        private static int MergeBlocks(Block[] blocks, int blockCount, int version, DataSegmentMode mergedMode,
             Func<DataSegmentMode, DataSegmentMode, DataSegmentMode, bool> merge3Condition,
             Func<DataSegmentMode, DataSegmentMode, bool> merge2Condition)
         {
             var previousCount = -1;
-            while (blocks.Count > 1 && previousCount != blocks.Count)
+            while (blockCount > 1 && previousCount != blockCount)
             {
-                previousCount = blocks.Count;
-
-                // Work back to front to reduce the amount of copying in `blocks`
-                var index = blocks.Count - 1;
-                while (index > 0)
+                previousCount = blockCount;
+                
+                var targetIndex = 1;
+                var sourceIndex = 1;
+                while (sourceIndex < blockCount)
                 {
-                    var mode0 = blocks[index].Mode;
-                    var mode1 = blocks[index - 1].Mode;
-                    DataSegmentMode? mode2 = index >= 2 ? blocks[index - 2].Mode : (DataSegmentMode?) null;
+                    var merged = false;
+                    var mode0 = blocks[targetIndex - 1].Mode;
+                    var mode1 = blocks[sourceIndex].Mode;
 
-                    // Case 1: merge 3 blocks
+                    // Case 1: merge 3 blocks (last processed one plus 2 unprocessed ones)
                     // Test if the bit stream is shorter if all 3 blocks are merged (using the specified merged mode).
-                    if (mode2 != null && merge3Condition(mode0, mode1, mode2.Value))
+                    if (sourceIndex + 1 < blockCount && merge3Condition(mode0, mode1, blocks[sourceIndex + 1].Mode))
                     {
                         var mergedPayloadLength =
-                            blocks[index - 2].Length + blocks[index - 1].Length + blocks[index].Length;
+                            blocks[targetIndex - 1].Length + blocks[sourceIndex].Length + blocks[sourceIndex + 1].Length;
                         var mergedBlock = new Block { Mode = mergedMode, Length = mergedPayloadLength };
                         var mergedLength = mergedBlock.GetSegmentLength(version);
-                        var separateLength = blocks[index - 2].GetSegmentLength(version)
-                                             + blocks[index - 1].GetSegmentLength(version)
-                                             + blocks[index].GetSegmentLength(version);
+                        var separateLength = blocks[targetIndex - 1].GetSegmentLength(version)
+                                             + blocks[sourceIndex].GetSegmentLength(version)
+                                             + blocks[sourceIndex + 1].GetSegmentLength(version);
                         if (mergedLength <= separateLength)
                         {
-                            blocks[index - 2] = mergedBlock;
-                            blocks.RemoveRange(index - 1, 2);
-                            index -= 1;
+                            blocks[targetIndex - 1] = mergedBlock;
+                            sourceIndex += 2;
+                            merged = true;
                         }
                     }
 
-                    // Case 2: merge 2 blocks
+                    // Case 2: merge 2 blocks (last processed one and the current unprocessed one)
                     // Test if the bit stream is shorter if the 2 blocks are merged (using the specified merged mode).
                     else if (merge2Condition(mode0, mode1))
                     {
-                        var mergedBlock = new Block
-                            { Mode = mergedMode, Length = blocks[index - 1].Length + blocks[index].Length };
+                        var mergedPayloadLength = blocks[targetIndex - 1].Length + blocks[sourceIndex].Length;
+                        var mergedBlock = new Block { Mode = mergedMode, Length = mergedPayloadLength };
                         var mergedLength = mergedBlock.GetSegmentLength(version);
-                        var separateLength = blocks[index - 1].GetSegmentLength(version) +
-                                             blocks[index].GetSegmentLength(version);
+                        var separateLength = blocks[targetIndex - 1].GetSegmentLength(version) +
+                                             blocks[sourceIndex].GetSegmentLength(version);
                         if (mergedLength <= separateLength)
                         {
-                            blocks[index - 1] = mergedBlock;
-                            blocks.RemoveAt(index);
+                            blocks[targetIndex - 1] = mergedBlock;
+                            sourceIndex += 1;
+                            merged = true;
                         }
                     }
-
-                    index -= 1;
+                    
+                    if (!merged)
+                    {
+                        blocks[targetIndex] = blocks[sourceIndex];
+                        targetIndex += 1;
+                        sourceIndex += 1;
+                    }
                 }
+                
+                blockCount = targetIndex;
             }
+            
+            return blockCount;
         }
 
         /// <summary>
@@ -146,17 +164,19 @@ private static void MergeBlocks(List<Block> blocks, int version, DataSegmentMode
         /// <param name="bytes">Bytes to process</param>
         /// <param name="useKanji">If <c>true</c>, Kanji encoding is considered; if <c>false</c>, Kanji encoding is not used.</param>
         /// <returns>List of blocks</returns>
-        private static List<Block> BuildBlocks(ArraySegment<byte> bytes, bool useKanji)
+        private static Block[] BuildBlocks(ArraySegment<byte> bytes, bool useKanji)
         {
             if (bytes.Count == 0)
             {
-                return new List<Block>();
+                return Array.Empty<Block>();
             }
 
             var modes = CalcCompactionMode(bytes, useKanji);
-
+            
             // create blocks
-            var blockList = new List<Block>();
+            var modeChanges = CountModeChanges(modes);
+            var blocks = new Block[modeChanges];
+            var blockCount = 0;
             var blockStartIndex = 0;
             var previousMode = modes[0];
             for (var i = 0; i < modes.Length; i += 1)
@@ -167,14 +187,30 @@ private static List<Block> BuildBlocks(ArraySegment<byte> bytes, bool useKanji)
                     continue;
                 }
 
-                blockList.Add(new Block { Mode = previousMode, Length = i - blockStartIndex });
+                blocks[blockCount] = new Block { Mode = (DataSegmentMode) previousMode, Length = i - blockStartIndex };
+                blockCount += 1;
                 previousMode = currentMode;
                 blockStartIndex = i;
             }
 
-            blockList.Add(new Block { Mode = previousMode, Length = modes.Length - blockStartIndex });
+            blocks[blockCount] = new Block { Mode = (DataSegmentMode) previousMode, Length = modes.Length - blockStartIndex };
+            return blocks;
+        }
 
-            return blockList;
+        private static int CountModeChanges(byte[] modes)
+        {
+            var count = 1;
+            var previousMode = modes[0];
+            for (var i = 0; i < modes.Length; i += 1)
+            {
+                var currentMode = modes[i];
+                if (currentMode != previousMode)
+                {
+                    count += 1;
+                    previousMode = currentMode;
+                }
+            }
+            return count;
         }
 
         /// <summary>
@@ -190,31 +226,31 @@ private static List<Block> BuildBlocks(ArraySegment<byte> bytes, bool useKanji)
         /// <param name="bytes">The bytes to encode.</param>
         /// <param name="useKanji">If <c>true</c>, Kanji encoding is considered; if <c>false</c>, Kanji encoding is not used.</param>
         /// <returns>An array of the best encoding mode for each byte.</returns>
-        private static DataSegmentMode[] CalcCompactionMode(ArraySegment<byte> bytes, bool useKanji)
+        private static byte[] CalcCompactionMode(ArraySegment<byte> bytes, bool useKanji)
         {
             var len = bytes.Count;
-            var modes = new DataSegmentMode[len];
+            var modes = new byte[len];
             var index = 0;
             while (index < len)
             {
                 var b1 = bytes.At(index);
                 if (DataSegmentNumeric.IsNumeric(b1))
                 {
-                    modes[index] = DataSegmentMode.Numeric;
+                    modes[index] = (byte) DataSegmentMode.Numeric;
                 }
                 else if (DataSegmentAlphanumeric.IsAlphanumeric(b1))
                 {
-                    modes[index] = DataSegmentMode.Alphanumeric;
+                    modes[index] = (byte) DataSegmentMode.Alphanumeric;
                 }
                 else if (useKanji && index < len - 1 && DataSegmentKanji.IsShiftJisDoubleByte(b1, bytes.At(index + 1)))
                 {
-                    modes[index] = DataSegmentMode.Kanji;
+                    modes[index] = (byte) DataSegmentMode.Kanji;
                     index += 1;
-                    modes[index] = DataSegmentMode.Kanji;
+                    modes[index] = (byte) DataSegmentMode.Kanji;
                 }
                 else
                 {
-                    modes[index] = DataSegmentMode.Binary;
+                    modes[index] = (byte) DataSegmentMode.Binary;
                 }
 
                 index += 1;
@@ -230,7 +266,7 @@ private static DataSegmentMode[] CalcCompactionMode(ArraySegment<byte> bytes, bo
         /// <summary>
         /// Block of bytes with an associated encoding mode.
         /// </summary>
-        private struct Block
+        internal struct Block
         {
             /// <summary>
             /// Encoding mode.
@@ -249,7 +285,21 @@ private struct Block
             /// <returns>Resulting segment length, in bits.</returns>
             internal int GetSegmentLength(int version)
             {
-                return DataSegment.GetBitLength(Mode, Length, version);
+                // Duplicated code for performance
+                switch (Mode)
+                {
+                    case DataSegmentMode.Binary:
+                        return 12 + (version <= 9 ? 0 : 8) + Length * 8;
+                    case DataSegmentMode.Numeric:
+                        return 14 + (version + 7) / 17 * 2 + (Length * 10 + 2) / 3;
+                    case DataSegmentMode.Alphanumeric:
+                        return 13 + (version + 7) / 17 * 2 + (Length * 11 + 1) / 2;
+                    case DataSegmentMode.Kanji:
+                        return 12 + (version + 7) / 17 * 2 + Length * 13 / 2;
+                }
+
+                Debug.Assert(false);
+                return 0;
             }
 
             public override string ToString()

QrCodeGeneratorTest/SegmentCompactionTest.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Runtime.Serialization.Formatters;
 using System.Text;
 using Xunit;
 using Xunit.Internal;
@@ -27,6 +26,14 @@ public static TheoryData<string, int, ECI, int> TestCases()
             return data;
         }
 
+        [Theory, CombinatorialData]
+        public static void TestBlockGetSegmentLength([CombinatorialRange(1, 4)] int modeIndex, [CombinatorialRange(0, 7)] int length, [CombinatorialRange(1, 40)] int version)
+        {
+            var mode = (DataSegmentMode)modeIndex;
+            var block = new SegmentCompaction.Block { Mode = mode, Length = length };
+            Assert.Equal(DataSegment.GetBitLength(mode, length, version), block.GetSegmentLength(version));
+        }
+
         private static IEnumerable<TestCase> GenerateTestCases()
         {
 #if NET