python
diff --git a/‎Include/cpython/unicodeobject.h‎
Lines changed: 13 additions & 7 deletions b/‎Include/cpython/unicodeobject.h‎
Lines changed: 13 additions & 7 deletions
diff --git a/‎Misc/NEWS.d/next/Core_and_Builtins/2024-12-24-01-40-12.gh-issue-128137.gsTwr_.rst‎
Lines changed: 2 additions & 0 deletions b/‎Misc/NEWS.d/next/Core_and_Builtins/2024-12-24-01-40-12.gh-issue-128137.gsTwr_.rst‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎Objects/unicodeobject.c‎
Lines changed: 3 additions & 3 deletions b/‎Objects/unicodeobject.c‎
Lines changed: 3 additions & 3 deletions
@@ -109,7 +109,7 @@ typedef struct {
                3: Interned, Immortal, and Static
            This categorization allows the runtime to determine the right
            cleanup mechanism at runtime shutdown. */
-        unsigned int interned:2;
+        uint16_t interned;
         /* Character size:
 
            - PyUnicode_1BYTE_KIND (1):
@@ -132,21 +132,23 @@ typedef struct {
              * all characters are in the range U+0000-U+10FFFF
              * at least one character is in the range U+10000-U+10FFFF
          */
-        unsigned int kind:3;
+        unsigned short kind:3;
         /* Compact is with respect to the allocation scheme. Compact unicode
            objects only require one memory block while non-compact objects use
            one block for the PyUnicodeObject struct and another for its data
            buffer. */
-        unsigned int compact:1;
+        unsigned short compact:1;
         /* The string only contains characters in the range U+0000-U+007F (ASCII)
            and the kind is PyUnicode_1BYTE_KIND. If ascii is set and compact is
            set, use the PyASCIIObject structure. */
-        unsigned int ascii:1;
+        unsigned short ascii:1;
         /* The object is statically allocated. */
-        unsigned int statically_allocated:1;
+        unsigned short statically_allocated:1;
         /* Padding to ensure that PyUnicode_DATA() is always aligned to
-           4 bytes (see issue #19537 on m68k). */
-        unsigned int :24;
+           4 bytes (see issue #19537 on m68k) and we use unsigned short to avoid
+           the extra four bytes on 32-bit Windows. This is restricted features
+           for specific compilers including GCC, MSVC, Clang and IBM's XL compiler. */
+        unsigned short :10;
     } state;
 } PyASCIIObject;
 
@@ -195,7 +197,11 @@ typedef struct {
 
 /* Use only if you know it's a string */
 static inline unsigned int PyUnicode_CHECK_INTERNED(PyObject *op) {
+#ifdef Py_GIL_DISABLED
+    return _Py_atomic_load_uint16_relaxed(&_PyASCIIObject_CAST(op)->state.interned);
+#else
     return _PyASCIIObject_CAST(op)->state.interned;
+#endif
 }
 #define PyUnicode_CHECK_INTERNED(op) PyUnicode_CHECK_INTERNED(_PyObject_CAST(op))
 
 
@@ -0,0 +1,2 @@
+Update :c:type:`PyASCIIObject` layout to handle interned field with the
+atomic operation. Patch by Donghee Na.
@@ -15729,7 +15729,7 @@ immortalize_interned(PyObject *s)
         _Py_DecRefTotal(_PyThreadState_GET());
     }
 #endif
-    _PyUnicode_STATE(s).interned = SSTATE_INTERNED_IMMORTAL;
+    FT_ATOMIC_STORE_UINT16_RELAXED(_PyUnicode_STATE(s).interned, SSTATE_INTERNED_IMMORTAL);
     _Py_SetImmortal(s);
 }
 
@@ -15848,7 +15848,7 @@ intern_common(PyInterpreterState *interp, PyObject *s /* stolen */,
         _Py_DecRefTotal(_PyThreadState_GET());
 #endif
     }
-    _PyUnicode_STATE(s).interned = SSTATE_INTERNED_MORTAL;
+    FT_ATOMIC_STORE_UINT16_RELAXED(_PyUnicode_STATE(s).interned, SSTATE_INTERNED_MORTAL);
 
     /* INTERNED_MORTAL -> INTERNED_IMMORTAL (if needed) */
 
@@ -15984,7 +15984,7 @@ _PyUnicode_ClearInterned(PyInterpreterState *interp)
             Py_UNREACHABLE();
         }
         if (!shared) {
-            _PyUnicode_STATE(s).interned = SSTATE_NOT_INTERNED;
+            FT_ATOMIC_STORE_UINT16_RELAXED(_PyUnicode_STATE(s).interned, SSTATE_NOT_INTERNED);
         }
     }
 #ifdef INTERNED_STATS
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	+Update :c:type:`PyASCIIObject` layout to handle interned field with the
	`2`	`+atomic operation. Patch by Donghee Na.`
Original file line number	Diff line number	Diff line change
`@@ -15729,7 +15729,7 @@ immortalize_interned(PyObject *s)`
`15729`	`15729`	`_Py_DecRefTotal(_PyThreadState_GET());`
`15730`	`15730`	`}`
`15731`	`15731`	`#endif`
`15732`		`- _PyUnicode_STATE(s).interned = SSTATE_INTERNED_IMMORTAL;`
	`15732`	`+ FT_ATOMIC_STORE_UINT16_RELAXED(_PyUnicode_STATE(s).interned, SSTATE_INTERNED_IMMORTAL);`
`15733`	`15733`	`_Py_SetImmortal(s);`
`15734`	`15734`	`}`
`15735`	`15735`
`@@ -15848,7 +15848,7 @@ intern_common(PyInterpreterState interp, PyObject s /* stolen */,`
`15848`	`15848`	`_Py_DecRefTotal(_PyThreadState_GET());`
`15849`	`15849`	`#endif`
`15850`	`15850`	`}`
`15851`		`- _PyUnicode_STATE(s).interned = SSTATE_INTERNED_MORTAL;`
	`15851`	`+ FT_ATOMIC_STORE_UINT16_RELAXED(_PyUnicode_STATE(s).interned, SSTATE_INTERNED_MORTAL);`
`15852`	`15852`
`15853`	`15853`	`/* INTERNED_MORTAL -> INTERNED_IMMORTAL (if needed) */`
`15854`	`15854`
`@@ -15984,7 +15984,7 @@ _PyUnicode_ClearInterned(PyInterpreterState *interp)`
`15984`	`15984`	`Py_UNREACHABLE();`
`15985`	`15985`	`}`
`15986`	`15986`	`if (!shared) {`
`15987`		`- _PyUnicode_STATE(s).interned = SSTATE_NOT_INTERNED;`
	`15987`	`+ FT_ATOMIC_STORE_UINT16_RELAXED(_PyUnicode_STATE(s).interned, SSTATE_NOT_INTERNED);`
`15988`	`15988`	`}`
`15989`	`15989`	`}`
`15990`	`15990`	`#ifdef INTERNED_STATS`