Merge branch 'main' into make-resource-tracker-reentrant-safe

Author: graingert

Include/cpython/tupleobject.h

@@ -4,6 +4,8 @@
 
 typedef struct {
     PyObject_VAR_HEAD
+    /* Cached hash.  Initially set to -1. */
+    Py_hash_t ob_hash;
     /* ob_item contains space for 'ob_size' elements.
        Items must normally not be NULL, except during construction when
        the tuple is not yet visible outside the function that builds it. */

Include/internal/pycore_runtime_init.h

@@ -27,6 +27,7 @@ extern "C" {
 #include "pycore_runtime_init_generated.h"  // _Py_bytes_characters_INIT
 #include "pycore_signal.h"        // _signals_RUNTIME_INIT
 #include "pycore_tracemalloc.h"   // _tracemalloc_runtime_state_INIT
+#include "pycore_tuple.h"         // _PyTuple_HASH_EMPTY
 
 
 extern PyTypeObject _PyExc_MemoryError;
@@ -106,6 +107,7 @@ extern PyTypeObject _PyExc_MemoryError;
                 }, \
                 .tuple_empty = { \
                     .ob_base = _PyVarObject_HEAD_INIT(&PyTuple_Type, 0), \
+                    .ob_hash = _PyTuple_HASH_EMPTY, \
                 }, \
                 .hamt_bitmap_node_empty = { \
                     .ob_base = _PyVarObject_HEAD_INIT(&_PyHamt_BitmapNode_Type, 0), \

Include/internal/pycore_stackref.h

@@ -35,13 +35,13 @@ extern "C" {
   unboxed integers harder in the future.
 
   Steal means that ownership is transferred to something else. The total
-  number of references to the object stays the same.
+  number of references to the object stays the same.  The old reference is no
+  longer valid.
 
   New creates a new reference from the old reference. The old reference
   is still valid.
 
-  With these 3 API, a strict stack discipline must be maintained. All
-  _PyStackRef must be operated on by the new reference operations:
+  All _PyStackRef must be operated on by the new reference operations:
 
     1. DUP
     2. CLOSE
@@ -668,7 +668,7 @@ static inline int
 _Py_TryIncrefCompareStackRef(PyObject **src, PyObject *op, _PyStackRef *out)
 {
     if (_PyObject_HasDeferredRefcount(op)) {
-        *out = (_PyStackRef){ .bits = (intptr_t)op | Py_TAG_DEFERRED };
+        *out = (_PyStackRef){ .bits = (uintptr_t)op | Py_TAG_DEFERRED };
         return 1;
     }
     if (_Py_TryIncrefCompare(src, op)) {

Include/internal/pycore_tuple.h

@@ -8,6 +8,7 @@ extern "C" {
 #  error "this header requires Py_BUILD_CORE define"
 #endif
 
+#include "pycore_object.h"        // _PyObject_GC_IS_TRACKED
 #include "pycore_structs.h"       // _PyStackRef
 
 extern void _PyTuple_MaybeUntrack(PyObject *);
@@ -32,6 +33,42 @@ typedef struct {
     PyTupleObject *it_seq; /* Set to NULL when iterator is exhausted */
 } _PyTupleIterObject;
 
+#define _PyTuple_RESET_HASH_CACHE(op)       \
+    do {                                    \
+        assert(op != NULL);                 \
+        _PyTuple_CAST(op)->ob_hash = -1;    \
+    } while (0)
+
+/* bpo-42536: If reusing a tuple object, this should be called to re-track it
+   with the garbage collector and reset its hash cache. */
+static inline void
+_PyTuple_Recycle(PyObject *op)
+{
+    _PyTuple_RESET_HASH_CACHE(op);
+    if (!_PyObject_GC_IS_TRACKED(op)) {
+        _PyObject_GC_TRACK(op);
+    }
+}
+
+/* Below are the official constants from the xxHash specification. Optimizing
+   compilers should emit a single "rotate" instruction for the
+   _PyTuple_HASH_XXROTATE() expansion. If that doesn't happen for some important
+   platform, the macro could be changed to expand to a platform-specific rotate
+   spelling instead.
+*/
+#if SIZEOF_PY_UHASH_T > 4
+#define _PyTuple_HASH_XXPRIME_1 ((Py_uhash_t)11400714785074694791ULL)
+#define _PyTuple_HASH_XXPRIME_2 ((Py_uhash_t)14029467366897019727ULL)
+#define _PyTuple_HASH_XXPRIME_5 ((Py_uhash_t)2870177450012600261ULL)
+#define _PyTuple_HASH_XXROTATE(x) ((x << 31) | (x >> 33))  /* Rotate left 31 bits */
+#else
+#define _PyTuple_HASH_XXPRIME_1 ((Py_uhash_t)2654435761UL)
+#define _PyTuple_HASH_XXPRIME_2 ((Py_uhash_t)2246822519UL)
+#define _PyTuple_HASH_XXPRIME_5 ((Py_uhash_t)374761393UL)
+#define _PyTuple_HASH_XXROTATE(x) ((x << 13) | (x >> 19))  /* Rotate left 13 bits */
+#endif
+#define _PyTuple_HASH_EMPTY (_PyTuple_HASH_XXPRIME_5 + (_PyTuple_HASH_XXPRIME_5 ^ 3527539UL))
+
 #ifdef __cplusplus
 }
 #endif

Lib/locale.py

@@ -13,7 +13,6 @@
 import sys
 import encodings
 import encodings.aliases
-import re
 import _collections_abc
 from builtins import str as _builtin_str
 import functools
@@ -177,8 +176,7 @@ def _strip_padding(s, amount):
         amount -= 1
     return s[lpos:rpos+1]
 
-_percent_re = re.compile(r'%(?:\((?P<key>.*?)\))?'
-                         r'(?P<modifiers>[-#0-9 +*.hlL]*?)[eEfFgGdiouxXcrs%]')
+_percent_re = None
 
 def _format(percent, value, grouping=False, monetary=False, *additional):
     if additional:
@@ -217,6 +215,13 @@ def format_string(f, val, grouping=False, monetary=False):
     Grouping is applied if the third parameter is true.
     Conversion uses monetary thousands separator and grouping strings if
     forth parameter monetary is true."""
+    global _percent_re
+    if _percent_re is None:
+        import re
+
+        _percent_re = re.compile(r'%(?:\((?P<key>.*?)\))?(?P<modifiers'
+                                 r'>[-#0-9 +*.hlL]*?)[eEfFgGdiouxXcrs%]')
+
     percents = list(_percent_re.finditer(f))
     new_f = _percent_re.sub('%s', f)