Merged PR 101766: Move to marvin hashing for OrdinalIgnoreCase CompareInfo & StringComparers

Move to marvin hashing for OrdinalIgnoreCase CompareInfo & StringComparers

Author: Viktor Hofer

src/classlibnative/bcltype/stringnative.cpp

@@ -187,6 +187,25 @@ FCIMPL3(INT32, COMString::Marvin32HashString, StringObject* thisRefUNSAFE, INT32
 }
 FCIMPLEND
 
+FCIMPL2(INT32, COMString::Marvin32HashPtr, WCHAR *pRawStr, INT32 strLen) {
+    FCALL_CONTRACT;
+
+    int iReturnHash = 0;
+
+    if (pRawStr == NULL) {
+        FCThrow(kNullReferenceException);
+    }
+
+    BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), FCThrow(kStackOverflowException));
+    iReturnHash = GetCurrentNlsHashProvider()->HashString(pRawStr, strLen, TRUE, 0);
+    END_SO_INTOLERANT_CODE;
+
+    FC_GC_POLL_RET();
+
+    return iReturnHash;
+}
+FCIMPLEND
+
 BOOL QCALLTYPE COMString::UseRandomizedHashing() {
     QCALL_CONTRACT;
 

src/classlibnative/bcltype/stringnative.h

@@ -87,6 +87,7 @@ class COMString {
 
 #ifdef FEATURE_RANDOMIZED_STRING_HASHING
     static FCDECL3(INT32, Marvin32HashString, StringObject* thisRefUNSAFE, INT32 strLen, INT64 additionalEntropy);
+    static FCDECL2(INT32, Marvin32HashPtr, WCHAR *pRawStr, INT32 strLen);
     static BOOL QCALLTYPE UseRandomizedHashing();
 #endif // FEATURE_RANDOMIZED_STRING_HASHING
 

src/mscorlib/corefx/System/Globalization/TextInfo.cs

@@ -406,52 +406,43 @@ internal unsafe int GetCaseInsensitiveHashCode(String str)
                 throw new ArgumentNullException("str");
             }
 
+            // Do not allocate on the stack if string is empty
+            if (str.Length == 0)
+            {
+                return str.GetHashCode();
+            }
+
             // This code assumes that ASCII casing is safe for whatever context is passed in.
             // this is true today, because we only ever call these methods on Invariant.  It would be ideal to refactor
             // these methods so they were correct by construction and we could only ever use Invariant.
 
-            uint hash = 5381;
-            uint c;
+            // If the string contains Unicode characters or is longer than 250 characters
+            // we allocate on the heap --> slow path.
+            if (!str.IsAscii() || str.Length > 250)
+            {
+               return ToUpper(str).GetHashCode();
+            }
+
+            // For the common case of ascii-only short strings (less than 250 characters) we can allocate on the stack
+            // and upper case the characters.
+            char* charArr = stackalloc char[str.Length];
+            char c;
 
-            // Note: We assume that str contains only ASCII characters until
-            // we hit a non-ASCII character to optimize the common case.
             for (int i = 0; i < str.Length; i++)
             {
                 c = str[i];
-                if (c >= 0x80)
-                {
-                    return GetCaseInsensitiveHashCodeSlow(str);
-                }
 
                 // If we have a lowercase character, ANDing off 0x20
                 // will make it an uppercase character.
                 if ((c - 'a') <= ('z' - 'a'))
                 {
-                    c = (uint)((int)c & ~0x20);
+                    c = (char)(c & ~0x20);
                 }
 
-                hash = ((hash << 5) + hash) ^ c;
-            }
-
-            return (int)hash;
-        }
-
-        private unsafe int GetCaseInsensitiveHashCodeSlow(String str)
-        {
-            Contract.Assert(str != null);
-
-            string upper = ToUpper(str);
-
-            uint hash = 5381;
-            uint c;
-
-            for (int i = 0; i < upper.Length; i++)
-            {
-                c = upper[i];
-                hash = ((hash << 5) + hash) ^ c;
+                charArr[i] = c;
             }
 
-            return (int)hash;
+            return String.InternalMarvin32HashPtr(charArr, str.Length);
         }
     }
 }

src/mscorlib/src/System/String.Comparison.cs

@@ -985,6 +985,10 @@ public static bool Equals(String a, String b, StringComparison comparisonType) {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal static extern int InternalMarvin32HashString(string s, int strLen, long additionalEntropy);
 
+        [System.Security.SecurityCritical]
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal unsafe static extern int InternalMarvin32HashPtr(char* s, int strLen);
+
         [System.Security.SecuritySafeCritical]
         internal static bool UseRandomizedHashing() {
             return InternalUseRandomizedHashing();

src/vm/ecalllist.h

@@ -234,6 +234,7 @@ FCFuncStart(gStringFuncs)
 #endif // FEATURE_COMINTEROP
 #ifdef FEATURE_RANDOMIZED_STRING_HASHING
     FCFuncElement("InternalMarvin32HashString", COMString::Marvin32HashString)
+    FCFuncElement("InternalMarvin32HashPtr", COMString::Marvin32HashPtr)
     QCFuncElement("InternalUseRandomizedHashing", COMString::UseRandomizedHashing) 
 #endif // FEATURE_RANDOMIZED_STRING_HASHING
 FCFuncEnd()