Avoid unnecessary string allocations in IdnMapping (dotnet/coreclr#17399)

stephentoub · Anipik · commit ec067c83107f · 2018-04-09T13:51:01.000-07:00
If the output matches the input string, we can just use the input string as the result.

Signed-off-by: dotnet-bot-corefx-mirror &lt;dotnet-bot@microsoft.com&gt;
diff --git a/src/Common/src/CoreLib/System/Globalization/IdnMapping.Unix.cs b/src/Common/src/CoreLib/System/Globalization/IdnMapping.Unix.cs
@@ -8,9 +8,10 @@ namespace System.Globalization
 {
     sealed partial class IdnMapping
     {
-        private unsafe string GetAsciiCore(char* unicode, int count)
+        private unsafe string GetAsciiCore(string unicodeString, char* unicode, int count)
         {
             Debug.Assert(!GlobalizationMode.Invariant);
+            Debug.Assert(unicodeString != null && unicodeString.Length >= count);
 
             uint flags = Flags;
             CheckInvalidIdnCharacters(unicode, count, flags, nameof(unicode));
@@ -26,7 +27,7 @@ private unsafe string GetAsciiCore(char* unicode, int count)
                 actualLength = Interop.Globalization.ToAscii(flags, unicode, count, outputStack, estimatedLength);
                 if (actualLength > 0 && actualLength <= estimatedLength)
                 {
-                    return new string(outputStack, 0, actualLength);
+                    return GetStringForOutput(unicodeString, unicode, count, outputStack, actualLength);
                 }
             }
             else
@@ -46,13 +47,14 @@ private unsafe string GetAsciiCore(char* unicode, int count)
                 {
                     throw new ArgumentException(SR.Argument_IdnIllegalName, nameof(unicode));
                 }
-                return new string(pOutputHeap, 0, actualLength);
+                return GetStringForOutput(unicodeString, unicode, count, pOutputHeap, actualLength);
             }
         }
 
-        private unsafe string GetUnicodeCore(char* ascii, int count)
+        private unsafe string GetUnicodeCore(string asciiString, char* ascii, int count)
         {
             Debug.Assert(!GlobalizationMode.Invariant);
+            Debug.Assert(asciiString != null && asciiString.Length >= count);
 
             uint flags = Flags;
             CheckInvalidIdnCharacters(ascii, count, flags, nameof(ascii));
@@ -61,21 +63,22 @@ private unsafe string GetUnicodeCore(char* ascii, int count)
             if (count < StackAllocThreshold)
             {
                 char* output = stackalloc char[count];
-                return GetUnicodeCore(ascii, count, flags, output, count, reattempt: true);
+                return GetUnicodeCore(asciiString, ascii, count, flags, output, count, reattempt: true);
             }
             else
             {
                 char[] output = new char[count];
                 fixed (char* pOutput = &output[0])
                 {
-                    return GetUnicodeCore(ascii, count, flags, pOutput, count, reattempt: true);
+                    return GetUnicodeCore(asciiString, ascii, count, flags, pOutput, count, reattempt: true);
                 }
             }
         }
 
-        private unsafe string GetUnicodeCore(char* ascii, int count, uint flags, char* output, int outputLength, bool reattempt)
+        private unsafe string GetUnicodeCore(string asciiString, char* ascii, int count, uint flags, char* output, int outputLength, bool reattempt)
         {
             Debug.Assert(!GlobalizationMode.Invariant);
+            Debug.Assert(asciiString != null && asciiString.Length >= count);
 
             int realLen = Interop.Globalization.ToUnicode(flags, ascii, count, output, outputLength);
 
@@ -85,14 +88,14 @@ private unsafe string GetUnicodeCore(char* ascii, int count, uint flags, char* o
             }
             else if (realLen <= outputLength)
             {
-                return new string(output, 0, realLen);
+                return GetStringForOutput(asciiString, ascii, count, output, realLen);
             }
             else if (reattempt)
             {
                 char[] newOutput = new char[realLen];
                 fixed (char* pNewOutput = newOutput)
                 {
-                    return GetUnicodeCore(ascii, count, flags, pNewOutput, realLen, reattempt: false);
+                    return GetUnicodeCore(asciiString, ascii, count, flags, pNewOutput, realLen, reattempt: false);
                 }
             }
 
diff --git a/src/Common/src/CoreLib/System/Globalization/IdnMapping.Windows.cs b/src/Common/src/CoreLib/System/Globalization/IdnMapping.Windows.cs
@@ -9,9 +9,10 @@ namespace System.Globalization
 {
     public sealed partial class IdnMapping
     {
-        private unsafe string GetAsciiCore(char* unicode, int count)
+        private unsafe string GetAsciiCore(string unicodeString, char* unicode, int count)
         {
             Debug.Assert(!GlobalizationMode.Invariant);
+            Debug.Assert(unicodeString != null && unicodeString.Length >= count);
 
             uint flags = Flags;
 
@@ -27,34 +28,36 @@ private unsafe string GetAsciiCore(char* unicode, int count)
             if (length < StackAllocThreshold)
             {
                 char* output = stackalloc char[length];
-                return GetAsciiCore(unicode, count, flags, output, length);
+                return GetAsciiCore(unicodeString, unicode, count, flags, output, length);
             }
             else
             {
                 char[] output = new char[length];
                 fixed (char* pOutput = &output[0])
                 {
-                    return GetAsciiCore(unicode, count, flags, pOutput, length);
+                    return GetAsciiCore(unicodeString, unicode, count, flags, pOutput, length);
                 }
             }
         }
 
-        private unsafe string GetAsciiCore(char* unicode, int count, uint flags, char* output, int outputLength)
+        private unsafe string GetAsciiCore(string unicodeString, char* unicode, int count, uint flags, char* output, int outputLength)
         {
             Debug.Assert(!GlobalizationMode.Invariant);
+            Debug.Assert(unicodeString != null && unicodeString.Length >= count);
 
             int length = Interop.Normaliz.IdnToAscii(flags, unicode, count, output, outputLength);
             if (length == 0)
             {
                 ThrowForZeroLength(unicode: true);
             }
             Debug.Assert(length == outputLength);
-            return new string(output, 0, length);
+            return GetStringForOutput(unicodeString, unicode, count, output, length);
         }
 
-        private unsafe string GetUnicodeCore(char* ascii, int count)
+        private unsafe string GetUnicodeCore(string asciiString, char* ascii, int count)
         {
             Debug.Assert(!GlobalizationMode.Invariant);
+            Debug.Assert(asciiString != null && asciiString.Length >= count);
 
             uint flags = Flags;
 
@@ -70,29 +73,30 @@ private unsafe string GetUnicodeCore(char* ascii, int count)
             if (length < StackAllocThreshold)
             {
                 char* output = stackalloc char[length];
-                return GetUnicodeCore(ascii, count, flags, output, length);
+                return GetUnicodeCore(asciiString, ascii, count, flags, output, length);
             }
             else
             {
                 char[] output = new char[length];
                 fixed (char* pOutput = &output[0])
                 {
-                    return GetUnicodeCore(ascii, count, flags, pOutput, length);
+                    return GetUnicodeCore(asciiString, ascii, count, flags, pOutput, length);
                 }
             }
         }
 
-        private unsafe string GetUnicodeCore(char* ascii, int count, uint flags, char* output, int outputLength)
+        private unsafe string GetUnicodeCore(string asciiString, char* ascii, int count, uint flags, char* output, int outputLength)
         {
             Debug.Assert(!GlobalizationMode.Invariant);
+            Debug.Assert(asciiString != null && asciiString.Length >= count);
 
             int length = Interop.Normaliz.IdnToUnicode(flags, ascii, count, output, outputLength);
             if (length == 0)
             {
                 ThrowForZeroLength(unicode: false);
             }
             Debug.Assert(length == outputLength);
-            return new string(output, 0, length);
+            return GetStringForOutput(asciiString, ascii, count, output, length);
         }
 
         // -----------------------------
diff --git a/src/Common/src/CoreLib/System/Globalization/IdnMapping.cs b/src/Common/src/CoreLib/System/Globalization/IdnMapping.cs
@@ -25,6 +25,7 @@
 //  RFC 3492 - Punycode: A Bootstring encoding of Unicode for Internationalized Domain Names in Applications (IDNA)
 
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Text;
 
 namespace System.Globalization
@@ -93,7 +94,7 @@ public string GetAscii(string unicode, int index, int count)
             {
                 fixed (char* pUnicode = unicode)
                 {
-                    return GetAsciiCore(pUnicode + index, count);
+                    return GetAsciiCore(unicode, pUnicode + index, count);
                 }
             }
         }
@@ -137,7 +138,7 @@ public string GetUnicode(string ascii, int index, int count)
             {
                 fixed (char* pAscii = ascii)
                 {
-                    return GetUnicodeCore(pAscii + index, count);
+                    return GetUnicodeCore(ascii, pAscii + index, count);
                 }
             }
         }
@@ -156,6 +157,14 @@ public override int GetHashCode()
             return (_allowUnassigned ? 100 : 200) + (_useStd3AsciiRules ? 1000 : 2000);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe string GetStringForOutput(string originalString, char* input, int inputLength, char* output, int outputLength)
+        {
+            return originalString.Length == inputLength && new ReadOnlySpan<char>(input, inputLength).SequenceEqual(new ReadOnlySpan<char>(output, outputLength)) ?
+                originalString :
+                new string(output, 0, outputLength);
+        }
+
         //
         // Invariant implementation
         //

Original file line number	Diff line number	Diff line change
`@@ -8,9 +8,10 @@ namespace System.Globalization`
`8`	`8`	`{`
`9`	`9`	`sealed partial class IdnMapping`
`10`	`10`	`{`
`11`		`- private unsafe string GetAsciiCore(char* unicode, int count)`
	`11`	`+ private unsafe string GetAsciiCore(string unicodeString, char* unicode, int count)`
`12`	`12`	`{`
`13`	`13`	`Debug.Assert(!GlobalizationMode.Invariant);`
	`14`	`+ Debug.Assert(unicodeString != null && unicodeString.Length >= count);`
`14`	`15`
`15`	`16`	`uint flags = Flags;`
`16`	`17`	`CheckInvalidIdnCharacters(unicode, count, flags, nameof(unicode));`
`@@ -26,7 +27,7 @@ private unsafe string GetAsciiCore(char* unicode, int count)`
`26`	`27`	`actualLength = Interop.Globalization.ToAscii(flags, unicode, count, outputStack, estimatedLength);`
`27`	`28`	`if (actualLength > 0 && actualLength <= estimatedLength)`
`28`	`29`	`{`
`29`		`- return new string(outputStack, 0, actualLength);`
	`30`	`+ return GetStringForOutput(unicodeString, unicode, count, outputStack, actualLength);`
`30`	`31`	`}`
`31`	`32`	`}`
`32`	`33`	`else`
`@@ -46,13 +47,14 @@ private unsafe string GetAsciiCore(char* unicode, int count)`
`46`	`47`	`{`
`47`	`48`	`throw new ArgumentException(SR.Argument_IdnIllegalName, nameof(unicode));`
`48`	`49`	`}`
`49`		`- return new string(pOutputHeap, 0, actualLength);`
	`50`	`+ return GetStringForOutput(unicodeString, unicode, count, pOutputHeap, actualLength);`
`50`	`51`	`}`
`51`	`52`	`}`
`52`	`53`
`53`		`- private unsafe string GetUnicodeCore(char* ascii, int count)`
	`54`	`+ private unsafe string GetUnicodeCore(string asciiString, char* ascii, int count)`
`54`	`55`	`{`
`55`	`56`	`Debug.Assert(!GlobalizationMode.Invariant);`
	`57`	`+ Debug.Assert(asciiString != null && asciiString.Length >= count);`
`56`	`58`
`57`	`59`	`uint flags = Flags;`
`58`	`60`	`CheckInvalidIdnCharacters(ascii, count, flags, nameof(ascii));`
`@@ -61,21 +63,22 @@ private unsafe string GetUnicodeCore(char* ascii, int count)`
`61`	`63`	`if (count < StackAllocThreshold)`
`62`	`64`	`{`
`63`	`65`	`char* output = stackalloc char[count];`
`64`		`- return GetUnicodeCore(ascii, count, flags, output, count, reattempt: true);`
	`66`	`+ return GetUnicodeCore(asciiString, ascii, count, flags, output, count, reattempt: true);`
`65`	`67`	`}`
`66`	`68`	`else`
`67`	`69`	`{`
`68`	`70`	`char[] output = new char[count];`
`69`	`71`	`fixed (char* pOutput = &output[0])`
`70`	`72`	`{`
`71`		`- return GetUnicodeCore(ascii, count, flags, pOutput, count, reattempt: true);`
	`73`	`+ return GetUnicodeCore(asciiString, ascii, count, flags, pOutput, count, reattempt: true);`
`72`	`74`	`}`
`73`	`75`	`}`
`74`	`76`	`}`
`75`	`77`
`76`		`- private unsafe string GetUnicodeCore(char* ascii, int count, uint flags, char* output, int outputLength, bool reattempt)`
	`78`	`+ private unsafe string GetUnicodeCore(string asciiString, char* ascii, int count, uint flags, char* output, int outputLength, bool reattempt)`
`77`	`79`	`{`
`78`	`80`	`Debug.Assert(!GlobalizationMode.Invariant);`
	`81`	`+ Debug.Assert(asciiString != null && asciiString.Length >= count);`
`79`	`82`
`80`	`83`	`int realLen = Interop.Globalization.ToUnicode(flags, ascii, count, output, outputLength);`
`81`	`84`
`@@ -85,14 +88,14 @@ private unsafe string GetUnicodeCore(char* ascii, int count, uint flags, char* o`
`85`	`88`	`}`
`86`	`89`	`else if (realLen <= outputLength)`
`87`	`90`	`{`
`88`		`- return new string(output, 0, realLen);`
	`91`	`+ return GetStringForOutput(asciiString, ascii, count, output, realLen);`
`89`	`92`	`}`
`90`	`93`	`else if (reattempt)`
`91`	`94`	`{`
`92`	`95`	`char[] newOutput = new char[realLen];`
`93`	`96`	`fixed (char* pNewOutput = newOutput)`
`94`	`97`	`{`
`95`		`- return GetUnicodeCore(ascii, count, flags, pNewOutput, realLen, reattempt: false);`
	`98`	`+ return GetUnicodeCore(asciiString, ascii, count, flags, pNewOutput, realLen, reattempt: false);`
`96`	`99`	`}`
`97`	`100`	`}`
`98`	`101`
Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,10 @@ namespace System.Globalization`
`9`	`9`	`{`
`10`	`10`	`public sealed partial class IdnMapping`
`11`	`11`	`{`
`12`		`- private unsafe string GetAsciiCore(char* unicode, int count)`
	`12`	`+ private unsafe string GetAsciiCore(string unicodeString, char* unicode, int count)`
`13`	`13`	`{`
`14`	`14`	`Debug.Assert(!GlobalizationMode.Invariant);`
	`15`	`+ Debug.Assert(unicodeString != null && unicodeString.Length >= count);`
`15`	`16`
`16`	`17`	`uint flags = Flags;`
`17`	`18`
`@@ -27,34 +28,36 @@ private unsafe string GetAsciiCore(char* unicode, int count)`
`27`	`28`	`if (length < StackAllocThreshold)`
`28`	`29`	`{`
`29`	`30`	`char* output = stackalloc char[length];`
`30`		`- return GetAsciiCore(unicode, count, flags, output, length);`
	`31`	`+ return GetAsciiCore(unicodeString, unicode, count, flags, output, length);`
`31`	`32`	`}`
`32`	`33`	`else`
`33`	`34`	`{`
`34`	`35`	`char[] output = new char[length];`
`35`	`36`	`fixed (char* pOutput = &output[0])`
`36`	`37`	`{`
`37`		`- return GetAsciiCore(unicode, count, flags, pOutput, length);`
	`38`	`+ return GetAsciiCore(unicodeString, unicode, count, flags, pOutput, length);`
`38`	`39`	`}`
`39`	`40`	`}`
`40`	`41`	`}`
`41`	`42`
`42`		`- private unsafe string GetAsciiCore(char* unicode, int count, uint flags, char* output, int outputLength)`
	`43`	`+ private unsafe string GetAsciiCore(string unicodeString, char* unicode, int count, uint flags, char* output, int outputLength)`
`43`	`44`	`{`
`44`	`45`	`Debug.Assert(!GlobalizationMode.Invariant);`
	`46`	`+ Debug.Assert(unicodeString != null && unicodeString.Length >= count);`
`45`	`47`
`46`	`48`	`int length = Interop.Normaliz.IdnToAscii(flags, unicode, count, output, outputLength);`
`47`	`49`	`if (length == 0)`
`48`	`50`	`{`
`49`	`51`	`ThrowForZeroLength(unicode: true);`
`50`	`52`	`}`
`51`	`53`	`Debug.Assert(length == outputLength);`
`52`		`- return new string(output, 0, length);`
	`54`	`+ return GetStringForOutput(unicodeString, unicode, count, output, length);`
`53`	`55`	`}`
`54`	`56`
`55`		`- private unsafe string GetUnicodeCore(char* ascii, int count)`
	`57`	`+ private unsafe string GetUnicodeCore(string asciiString, char* ascii, int count)`
`56`	`58`	`{`
`57`	`59`	`Debug.Assert(!GlobalizationMode.Invariant);`
	`60`	`+ Debug.Assert(asciiString != null && asciiString.Length >= count);`
`58`	`61`
`59`	`62`	`uint flags = Flags;`
`60`	`63`
`@@ -70,29 +73,30 @@ private unsafe string GetUnicodeCore(char* ascii, int count)`
`70`	`73`	`if (length < StackAllocThreshold)`
`71`	`74`	`{`
`72`	`75`	`char* output = stackalloc char[length];`
`73`		`- return GetUnicodeCore(ascii, count, flags, output, length);`
	`76`	`+ return GetUnicodeCore(asciiString, ascii, count, flags, output, length);`
`74`	`77`	`}`
`75`	`78`	`else`
`76`	`79`	`{`
`77`	`80`	`char[] output = new char[length];`
`78`	`81`	`fixed (char* pOutput = &output[0])`
`79`	`82`	`{`
`80`		`- return GetUnicodeCore(ascii, count, flags, pOutput, length);`
	`83`	`+ return GetUnicodeCore(asciiString, ascii, count, flags, pOutput, length);`
`81`	`84`	`}`
`82`	`85`	`}`
`83`	`86`	`}`
`84`	`87`
`85`		`- private unsafe string GetUnicodeCore(char* ascii, int count, uint flags, char* output, int outputLength)`
	`88`	`+ private unsafe string GetUnicodeCore(string asciiString, char* ascii, int count, uint flags, char* output, int outputLength)`
`86`	`89`	`{`
`87`	`90`	`Debug.Assert(!GlobalizationMode.Invariant);`
	`91`	`+ Debug.Assert(asciiString != null && asciiString.Length >= count);`
`88`	`92`
`89`	`93`	`int length = Interop.Normaliz.IdnToUnicode(flags, ascii, count, output, outputLength);`
`90`	`94`	`if (length == 0)`
`91`	`95`	`{`
`92`	`96`	`ThrowForZeroLength(unicode: false);`
`93`	`97`	`}`
`94`	`98`	`Debug.Assert(length == outputLength);`
`95`		`- return new string(output, 0, length);`
	`99`	`+ return GetStringForOutput(asciiString, ascii, count, output, length);`
`96`	`100`	`}`
`97`	`101`
`98`	`102`	`// -----------------------------`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@`
`25`	`25`	`// RFC 3492 - Punycode: A Bootstring encoding of Unicode for Internationalized Domain Names in Applications (IDNA)`
`26`	`26`
`27`	`27`	`using System.Diagnostics;`
	`28`	`+using System.Runtime.CompilerServices;`
`28`	`29`	`using System.Text;`
`29`	`30`
`30`	`31`	`namespace System.Globalization`
`@@ -93,7 +94,7 @@ public string GetAscii(string unicode, int index, int count)`
`93`	`94`	`{`
`94`	`95`	`fixed (char* pUnicode = unicode)`
`95`	`96`	`{`
`96`		`- return GetAsciiCore(pUnicode + index, count);`
	`97`	`+ return GetAsciiCore(unicode, pUnicode + index, count);`
`97`	`98`	`}`
`98`	`99`	`}`
`99`	`100`	`}`
`@@ -137,7 +138,7 @@ public string GetUnicode(string ascii, int index, int count)`
`137`	`138`	`{`
`138`	`139`	`fixed (char* pAscii = ascii)`
`139`	`140`	`{`
`140`		`- return GetUnicodeCore(pAscii + index, count);`
	`141`	`+ return GetUnicodeCore(ascii, pAscii + index, count);`
`141`	`142`	`}`
`142`	`143`	`}`
`143`	`144`	`}`
`@@ -156,6 +157,14 @@ public override int GetHashCode()`
`156`	`157`	`return (_allowUnassigned ? 100 : 200) + (_useStd3AsciiRules ? 1000 : 2000);`
`157`	`158`	`}`
`158`	`159`
	`160`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`161`	`+ private static unsafe string GetStringForOutput(string originalString, char* input, int inputLength, char* output, int outputLength)`
	`162`	`+ {`
	`163`	`+ return originalString.Length == inputLength && new ReadOnlySpan<char>(input, inputLength).SequenceEqual(new ReadOnlySpan<char>(output, outputLength)) ?`
	`164`	`+ originalString :`
	`165`	`+ new string(output, 0, outputLength);`
	`166`	`+ }`
	`167`	`+`
`159`	`168`	`//`
`160`	`169`	`// Invariant implementation`
`161`	`170`	`//`