Use unicode hash/compare for mcache.

This allows cache to work with non-interned strings.

Author: nascheme

Objects/typeobject.c

@@ -43,13 +43,46 @@ class object "PyObject *" "&PyBaseObject_Type"
    MCACHE_MAX_ATTR_SIZE, since it might be a problem if very large
    strings are used as attribute names. */
 #define MCACHE_MAX_ATTR_SIZE    100
-#define MCACHE_HASH(version, name_hash)                                 \
-        (((unsigned int)(version) ^ (unsigned int)(name_hash))          \
-         & ((1 << MCACHE_SIZE_EXP) - 1))
 
-#define MCACHE_HASH_METHOD(type, name)                                  \
-    MCACHE_HASH(FT_ATOMIC_LOAD_UINT32_RELAXED((type)->tp_version_tag),   \
-                ((Py_ssize_t)(name)) >> 3)
+static inline unsigned int
+mcache_name_hash(PyTypeObject *type, PyObject *name)
+{
+    unsigned int name_hash;
+#if Py_GIL_DISABLED
+    // Cache misses are relatively more expensive for the free-threaded build.
+    // So we use the unicode string hash and unicode compare for caching
+    // names.  This allows caching of non-interned strings.
+    if (PyUnicode_CheckExact(name)) {
+        name_hash = (unsigned int)_PyObject_HashFast(name);
+    }
+    else {
+        name_hash = 0;
+    }
+#else
+    // Use the pointer value of the string for the hash and the compare.  This
+    // is faster but non-interned strings can't use the cache.
+    name_hash = ((Py_ssize_t)(name)) >> 3;
+#endif
+    unsigned int version = FT_ATOMIC_LOAD_UINT32_RELAXED((type)->tp_version_tag);
+    return (((unsigned int)(version) ^ (unsigned int)(name_hash)) &
+            ((1 << MCACHE_SIZE_EXP) - 1));
+}
+
+static inline int
+mcache_name_eq(PyObject *entry_name,  PyObject *name)
+{
+#ifdef Py_GIL_DISABLED
+    if (entry_name == NULL || entry_name == Py_None) {
+        return 0;
+    }
+    assert(PyUnicode_CheckExact(entry_name));
+    assert(PyUnicode_Check(name));
+    return _PyUnicode_Equal(entry_name, name);
+#else
+    return entry_name == name;
+#endif
+}
+
 #define MCACHE_CACHEABLE_NAME(name)                             \
         PyUnicode_CheckExact(name) &&                           \
         (PyUnicode_GET_LENGTH(name) <= MCACHE_MAX_ATTR_SIZE)
@@ -5721,7 +5754,7 @@ _PyType_LookupRefAndVersion(PyTypeObject *type, PyObject *name, unsigned int *ve
 unsigned int
 _PyType_LookupStackRefAndVersion(PyTypeObject *type, PyObject *name, _PyStackRef *out)
 {
-    unsigned int h = MCACHE_HASH_METHOD(type, name);
+    unsigned int h = mcache_name_hash(type, name);
     struct type_cache *cache = get_type_cache();
     struct type_cache_entry *entry = &cache->hashtable[h];
 #ifdef Py_GIL_DISABLED
@@ -5731,7 +5764,7 @@ _PyType_LookupStackRefAndVersion(PyTypeObject *type, PyObject *name, _PyStackRef
         uint32_t entry_version = _Py_atomic_load_uint32_acquire(&entry->version);
         uint32_t type_version = _Py_atomic_load_uint32_acquire(&type->tp_version_tag);
         if (entry_version == type_version &&
-            _Py_atomic_load_ptr_relaxed(&entry->name) == name) {
+            mcache_name_eq(_Py_atomic_load_ptr_relaxed(&entry->name), name)) {
             OBJECT_STAT_INC_COND(type_cache_hits, !is_dunder_name(name));
             OBJECT_STAT_INC_COND(type_cache_dunder_hits, is_dunder_name(name));
             if (_Py_TryXGetStackRef(&entry->value, out)) {
@@ -5752,7 +5785,7 @@ _PyType_LookupStackRefAndVersion(PyTypeObject *type, PyObject *name, _PyStackRef
         }
     }
 #else
-    if (entry->version == type->tp_version_tag && entry->name == name) {
+    if (entry->version == type->tp_version_tag && mcache_name_eq(entry->name, name)) {
         assert(type->tp_version_tag);
         OBJECT_STAT_INC_COND(type_cache_hits, !is_dunder_name(name));
         OBJECT_STAT_INC_COND(type_cache_dunder_hits, is_dunder_name(name));