Use thread-local storage for transient memory requirements of blocked cells

Shane32 · Shane32 · commit 6b3e6a068547 · 2024-05-19T15:34:35.000-04:00
diff --git a/QRCoder/QRCodeGenerator.ModulePlacer.BlockedModules.cs b/QRCoder/QRCodeGenerator.ModulePlacer.BlockedModules.cs
@@ -1,4 +1,5 @@
-﻿using System.Collections;
+﻿using System;
+using System.Collections;
 
 namespace QRCoder
 {
@@ -9,20 +10,32 @@ private static partial class ModulePlacer
             /// <summary>
             /// Struct that represents blocked modules using rectangles.
             /// </summary>
-            public struct BlockedModules
+            public struct BlockedModules : IDisposable
             {
-                private readonly BitArray[] _blockedModules;
+                private readonly bool[,] _blockedModules;
+
+                [ThreadStatic]
+                private static bool[,] _staticBlockedModules;
 
                 /// <summary>
                 /// Initializes a new instance of the <see cref="BlockedModules"/> struct with a specified capacity.
                 /// </summary>
                 /// <param name="capacity">The initial capacity of the blocked modules list.</param>
                 public BlockedModules(int size)
                 {
-                    _blockedModules = new BitArray[size];
-                    for (int i = 0; i < size; i++)
+                    if (_staticBlockedModules != null && _staticBlockedModules.GetUpperBound(0) >= (size - 1))
+                    {
+                        _blockedModules = _staticBlockedModules;
+                        _staticBlockedModules = null;
+#if NET6_0_OR_GREATER
+                        Array.Clear(_blockedModules);
+#else
+                        Array.Clear(_blockedModules, 0, _blockedModules.Length);
+#endif
+                    }
+                    else
                     {
-                        _blockedModules[i] = new BitArray(size);
+                        _blockedModules = new bool[size, size];
                     }
                 }
 
@@ -33,7 +46,7 @@ public BlockedModules(int size)
                 /// <param name="y">The y-coordinate of the module.</param>
                 public void Add(int x, int y)
                 {
-                    _blockedModules[y][x] = true;
+                    _blockedModules[y, x] = true;
                 }
 
                 /// <summary>
@@ -46,7 +59,7 @@ public void Add(Rectangle rect)
                     {
                         for (int x = rect.X; x < rect.X + rect.Width; x++)
                         {
-                            _blockedModules[y][x] = true;
+                            _blockedModules[y, x] = true;
                         }
                     }
                 }
@@ -59,7 +72,7 @@ public void Add(Rectangle rect)
                 /// <returns><c>true</c> if the coordinates are blocked; otherwise, <c>false</c>.</returns>
                 public bool IsBlocked(int x, int y)
                 {
-                    return _blockedModules[y][x];
+                    return _blockedModules[y, x];
                 }
 
                 /// <summary>
@@ -73,12 +86,20 @@ public bool IsBlocked(Rectangle r1)
                     {
                         for (int x = r1.X; x < r1.X + r1.Width; x++)
                         {
-                            if (_blockedModules[y][x])
+                            if (_blockedModules[y, x])
                                 return true;
                         }
                     }
                     return false;
                 }
+
+                public void Dispose()
+                {
+                    if (_staticBlockedModules == null || _staticBlockedModules.GetUpperBound(0) < _blockedModules.GetUpperBound(0))
+                    {
+                        _staticBlockedModules = _blockedModules;
+                    }
+                }
             }
         }
     }
diff --git a/QRCoder/QRCodeGenerator.ModulePlacer.cs b/QRCoder/QRCodeGenerator.ModulePlacer.cs
@@ -114,7 +114,13 @@ public static int MaskCode(QRCodeData qrCode, int version, BlockedModules blocke
 
                 // Temporary QRCodeData object to test different mask patterns without altering the original.
                 var qrTemp = new QRCodeData(version, false);
-                BitArray versionString = version >= 7 ? GetVersionString(version) : null;
+                BitArray versionString = null;
+                if (version >= 7)
+                {
+                    versionString = new BitArray(18);
+                    GetVersionString(versionString, version);
+                }
+                var formatStr = new BitArray(15);
                 foreach (var pattern in MaskPattern.Patterns)
                 {
                     // Reset the temporary QR code to the current state of the actual QR code.
@@ -127,7 +133,7 @@ public static int MaskCode(QRCodeData qrCode, int version, BlockedModules blocke
                     }
 
                     // Place format information using the current mask pattern.
-                    var formatStr = GetFormatString(eccLevel, pattern.Key - 1);
+                    GetFormatString(formatStr, eccLevel, pattern.Key - 1);
                     ModulePlacer.PlaceFormat(qrTemp, formatStr, false);
 
                     // Place version information if applicable.
@@ -181,6 +187,7 @@ public static int MaskCode(QRCodeData qrCode, int version, BlockedModules blocke
                         qrCode.ModuleMatrix[x + 4][x + 4] ^= MaskPattern.Patterns[selectedPattern.Value](x, x);
                     }
                 }
+
                 return selectedPattern.Value - 1;
             }
 
diff --git a/QRCoder/QRCodeGenerator.cs b/QRCoder/QRCodeGenerator.cs
@@ -321,22 +321,25 @@ QRCodeData PlaceModules()
             {
                 var qr = new QRCodeData(version, true);
                 var size = qr.ModuleMatrix.Count - 8;
-                var blockedModules = new ModulePlacer.BlockedModules(size);
-                ModulePlacer.PlaceFinderPatterns(qr, blockedModules);
-                ModulePlacer.ReserveSeperatorAreas(size, blockedModules);
-                ModulePlacer.PlaceAlignmentPatterns(qr, alignmentPatternTable[version].PatternPositions, blockedModules);
-                ModulePlacer.PlaceTimingPatterns(qr, blockedModules);
-                ModulePlacer.PlaceDarkModule(qr, version, blockedModules);
-                ModulePlacer.ReserveVersionAreas(size, version, blockedModules);
-                ModulePlacer.PlaceDataWords(qr, interleavedData, blockedModules);
-                var maskVersion = ModulePlacer.MaskCode(qr, version, blockedModules, eccLevel);
-                var formatStr = GetFormatString(eccLevel, maskVersion);
-
-                ModulePlacer.PlaceFormat(qr, formatStr, true);
+                var tempBitArray = new BitArray(18); //version string requires 18 bits
+                using (var blockedModules = new ModulePlacer.BlockedModules(size))
+                {
+                    ModulePlacer.PlaceFinderPatterns(qr, blockedModules);
+                    ModulePlacer.ReserveSeperatorAreas(size, blockedModules);
+                    ModulePlacer.PlaceAlignmentPatterns(qr, alignmentPatternTable[version].PatternPositions, blockedModules);
+                    ModulePlacer.PlaceTimingPatterns(qr, blockedModules);
+                    ModulePlacer.PlaceDarkModule(qr, version, blockedModules);
+                    ModulePlacer.ReserveVersionAreas(size, version, blockedModules);
+                    ModulePlacer.PlaceDataWords(qr, interleavedData, blockedModules);
+                    var maskVersion = ModulePlacer.MaskCode(qr, version, blockedModules, eccLevel);
+                    GetFormatString(tempBitArray, eccLevel, maskVersion);
+                    ModulePlacer.PlaceFormat(qr, tempBitArray, true);
+                }
+
                 if (version >= 7)
                 {
-                    var versionString = GetVersionString(version);
-                    ModulePlacer.PlaceVersion(qr, versionString, true);
+                    GetVersionString(tempBitArray, version);
+                    ModulePlacer.PlaceVersion(qr, tempBitArray, true);
                 }
 
                 return qr;
@@ -349,12 +352,14 @@ QRCodeData PlaceModules()
         /// Generates a BitArray containing the format string for a QR code based on the error correction level and mask pattern version.
         /// The format string includes the error correction level, mask pattern version, and error correction coding.
         /// </summary>
+        /// <param name="bitArray">The <see cref="BitArray"/> to write to, or null to create a new one.</param>
         /// <param name="level">The error correction level to be encoded in the format string.</param>
         /// <param name="maskVersion">The mask pattern version to be encoded in the format string.</param>
         /// <returns>A BitArray containing the 15-bit format string used in QR code generation.</returns>
-        private static BitArray GetFormatString(ECCLevel level, int maskVersion)
+        private static void GetFormatString(BitArray fStrEcc, ECCLevel level, int maskVersion)
         {
-            var fStrEcc = new BitArray(15); // Total length including space for mask version and padding
+            fStrEcc.Length = 15;
+            fStrEcc.SetAll(false);
             WriteEccLevelAndVersion();
 
             // Apply the format generator polynomial to add error correction to the format string.
@@ -378,7 +383,6 @@ private static BitArray GetFormatString(ECCLevel level, int maskVersion)
 
             // XOR the format string with a predefined mask to add robustness against errors.
             fStrEcc.Xor(_getFormatMask);
-            return fStrEcc;
 
             void WriteEccLevelAndVersion()
             {
@@ -445,11 +449,13 @@ private static void ShiftAwayFromBit0(BitArray fStrEcc, int num)
         /// Encodes the version information of a QR code into a BitArray using error correction coding similar to format information encoding.
         /// This method is used for QR codes version 7 and above.
         /// </summary>
+        /// <param name="vStr">A <see cref="BitArray"/> to write the version string to.</param>
         /// <param name="version">The version number of the QR code (7-40).</param>
         /// <returns>A BitArray containing the encoded version information, which includes error correction bits.</returns>
-        private static BitArray GetVersionString(int version)
+        private static void GetVersionString(BitArray vStr, int version)
         {
-            var vStr = new BitArray(18);
+            vStr.Length = 18;
+            vStr.SetAll(false);
             DecToBin(version, 6, vStr, 0); // Convert the version number to a 6-bit binary representation.
 
             var count = vStr.Length;
@@ -471,8 +477,6 @@ private static BitArray GetVersionString(int version)
             vStr.Length = 12 + 6;
             ShiftAwayFromBit0(vStr, (12 - count) + 6);
             DecToBin(version, 6, vStr, 0);
-
-            return vStr;
         }
 
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System.Collections;`
	`1`	`+using System;`
	`2`	`+using System.Collections;`
`2`	`3`
`3`	`4`	`namespace QRCoder`
`4`	`5`	`{`
`@@ -9,20 +10,32 @@ private static partial class ModulePlacer`
`9`	`10`	`/// <summary>`
`10`	`11`	`/// Struct that represents blocked modules using rectangles.`
`11`	`12`	`/// </summary>`
`12`		`- public struct BlockedModules`
	`13`	`+ public struct BlockedModules : IDisposable`
`13`	`14`	`{`
`14`		`- private readonly BitArray[] _blockedModules;`
	`15`	`+ private readonly bool[,] _blockedModules;`
	`16`	`+`
	`17`	`+ [ThreadStatic]`
	`18`	`+ private static bool[,] _staticBlockedModules;`
`15`	`19`
`16`	`20`	`/// <summary>`
`17`	`21`	`/// Initializes a new instance of the <see cref="BlockedModules"/> struct with a specified capacity.`
`18`	`22`	`/// </summary>`
`19`	`23`	`/// <param name="capacity">The initial capacity of the blocked modules list.</param>`
`20`	`24`	`public BlockedModules(int size)`
`21`	`25`	`{`
`22`		`- _blockedModules = new BitArray[size];`
`23`		`- for (int i = 0; i < size; i++)`
	`26`	`+ if (_staticBlockedModules != null && _staticBlockedModules.GetUpperBound(0) >= (size - 1))`
	`27`	`+ {`
	`28`	`+ _blockedModules = _staticBlockedModules;`
	`29`	`+ _staticBlockedModules = null;`
	`30`	`+#if NET6_0_OR_GREATER`
	`31`	`+ Array.Clear(_blockedModules);`
	`32`	`+#else`
	`33`	`+ Array.Clear(_blockedModules, 0, _blockedModules.Length);`
	`34`	`+#endif`
	`35`	`+ }`
	`36`	`+ else`
`24`	`37`	`{`
`25`		`- _blockedModules[i] = new BitArray(size);`
	`38`	`+ _blockedModules = new bool[size, size];`
`26`	`39`	`}`
`27`	`40`	`}`
`28`	`41`
`@@ -33,7 +46,7 @@ public BlockedModules(int size)`
`33`	`46`	`/// <param name="y">The y-coordinate of the module.</param>`
`34`	`47`	`public void Add(int x, int y)`
`35`	`48`	`{`
`36`		`- _blockedModules[y][x] = true;`
	`49`	`+ _blockedModules[y, x] = true;`
`37`	`50`	`}`
`38`	`51`
`39`	`52`	`/// <summary>`
`@@ -46,7 +59,7 @@ public void Add(Rectangle rect)`
`46`	`59`	`{`
`47`	`60`	`for (int x = rect.X; x < rect.X + rect.Width; x++)`
`48`	`61`	`{`
`49`		`- _blockedModules[y][x] = true;`
	`62`	`+ _blockedModules[y, x] = true;`
`50`	`63`	`}`
`51`	`64`	`}`
`52`	`65`	`}`
`@@ -59,7 +72,7 @@ public void Add(Rectangle rect)`
`59`	`72`	`/// <returns><c>true</c> if the coordinates are blocked; otherwise, <c>false</c>.</returns>`
`60`	`73`	`public bool IsBlocked(int x, int y)`
`61`	`74`	`{`
`62`		`- return _blockedModules[y][x];`
	`75`	`+ return _blockedModules[y, x];`
`63`	`76`	`}`
`64`	`77`
`65`	`78`	`/// <summary>`
`@@ -73,12 +86,20 @@ public bool IsBlocked(Rectangle r1)`
`73`	`86`	`{`
`74`	`87`	`for (int x = r1.X; x < r1.X + r1.Width; x++)`
`75`	`88`	`{`
`76`		`- if (_blockedModules[y][x])`
	`89`	`+ if (_blockedModules[y, x])`
`77`	`90`	`return true;`
`78`	`91`	`}`
`79`	`92`	`}`
`80`	`93`	`return false;`
`81`	`94`	`}`
	`95`	`+`
	`96`	`+ public void Dispose()`
	`97`	`+ {`
	`98`	`+ if (_staticBlockedModules == null \|\| _staticBlockedModules.GetUpperBound(0) < _blockedModules.GetUpperBound(0))`
	`99`	`+ {`
	`100`	`+ _staticBlockedModules = _blockedModules;`
	`101`	`+ }`
	`102`	`+ }`
`82`	`103`	`}`
`83`	`104`	`}`
`84`	`105`	`}`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,13 @@ public static int MaskCode(QRCodeData qrCode, int version, BlockedModules blocke`
`114`	`114`
`115`	`115`	`// Temporary QRCodeData object to test different mask patterns without altering the original.`
`116`	`116`	`var qrTemp = new QRCodeData(version, false);`
`117`		`- BitArray versionString = version >= 7 ? GetVersionString(version) : null;`
	`117`	`+ BitArray versionString = null;`
	`118`	`+ if (version >= 7)`
	`119`	`+ {`
	`120`	`+ versionString = new BitArray(18);`
	`121`	`+ GetVersionString(versionString, version);`
	`122`	`+ }`
	`123`	`+ var formatStr = new BitArray(15);`
`118`	`124`	`foreach (var pattern in MaskPattern.Patterns)`
`119`	`125`	`{`
`120`	`126`	`// Reset the temporary QR code to the current state of the actual QR code.`
`@@ -127,7 +133,7 @@ public static int MaskCode(QRCodeData qrCode, int version, BlockedModules blocke`
`127`	`133`	`}`
`128`	`134`
`129`	`135`	`// Place format information using the current mask pattern.`
`130`		`- var formatStr = GetFormatString(eccLevel, pattern.Key - 1);`
	`136`	`+ GetFormatString(formatStr, eccLevel, pattern.Key - 1);`
`131`	`137`	`ModulePlacer.PlaceFormat(qrTemp, formatStr, false);`
`132`	`138`
`133`	`139`	`// Place version information if applicable.`
`@@ -181,6 +187,7 @@ public static int MaskCode(QRCodeData qrCode, int version, BlockedModules blocke`
`181`	`187`	`qrCode.ModuleMatrix[x + 4][x + 4] ^= MaskPattern.Patterns[selectedPattern.Value](x, x);`
`182`	`188`	`}`
`183`	`189`	`}`
	`190`	`+`
`184`	`191`	`return selectedPattern.Value - 1;`
`185`	`192`	`}`
`186`	`193`