gh-117657: Disable the function/code cache in free-threaded builds (#118301)

mpage · web-flow · commit 37d095002216 · 2024-05-03T16:21:04.000-04:00
This is only used by the specializing interpreter and the tier 2
optimizer, both of which are disabled in free-threaded builds.
diff --git a/Include/internal/pycore_function.h b/Include/internal/pycore_function.h
@@ -4,6 +4,8 @@
 extern "C" {
 #endif
 
+#include "pycore_lock.h"
+
 #ifndef Py_BUILD_CORE
 #  error "this header requires Py_BUILD_CORE define"
 #endif
@@ -24,6 +26,11 @@ struct _func_version_cache_item {
 };
 
 struct _py_func_state {
+#ifdef Py_GIL_DISABLED
+    // Protects next_version
+    PyMutex mutex;
+#endif
+
     uint32_t next_version;
     // Borrowed references to function and code objects whose
     // func_version % FUNC_VERSION_CACHE_SIZE
diff --git a/Objects/codeobject.c b/Objects/codeobject.c
@@ -416,10 +416,16 @@ init_code(PyCodeObject *co, struct _PyCodeConstructor *con)
     co->co_ncellvars = ncellvars;
     co->co_nfreevars = nfreevars;
     PyInterpreterState *interp = _PyInterpreterState_GET();
+#ifdef Py_GIL_DISABLED
+    PyMutex_Lock(&interp->func_state.mutex);
+#endif
     co->co_version = interp->func_state.next_version;
     if (interp->func_state.next_version != 0) {
         interp->func_state.next_version++;
     }
+#ifdef Py_GIL_DISABLED
+    PyMutex_Unlock(&interp->func_state.mutex);
+#endif
     co->_co_monitoring = NULL;
     co->_co_instrumentation_version = 0;
     /* not set */
diff --git a/Objects/funcobject.c b/Objects/funcobject.c
@@ -287,6 +287,7 @@ functions is running.
 void
 _PyFunction_SetVersion(PyFunctionObject *func, uint32_t version)
 {
+#ifndef Py_GIL_DISABLED
     PyInterpreterState *interp = _PyInterpreterState_GET();
     if (func->func_version != 0) {
         struct _func_version_cache_item *slot =
@@ -297,19 +298,23 @@ _PyFunction_SetVersion(PyFunctionObject *func, uint32_t version)
             // Leave slot->code alone, there may be use for it.
         }
     }
+#endif
     func->func_version = version;
+#ifndef Py_GIL_DISABLED
     if (version != 0) {
         struct _func_version_cache_item *slot =
             interp->func_state.func_version_cache
             + (version % FUNC_VERSION_CACHE_SIZE);
         slot->func = func;
         slot->code = func->func_code;
     }
+#endif
 }
 
 void
 _PyFunction_ClearCodeByVersion(uint32_t version)
 {
+#ifndef Py_GIL_DISABLED
     PyInterpreterState *interp = _PyInterpreterState_GET();
     struct _func_version_cache_item *slot =
         interp->func_state.func_version_cache
@@ -322,11 +327,15 @@ _PyFunction_ClearCodeByVersion(uint32_t version)
             slot->func = NULL;
         }
     }
+#endif
 }
 
 PyFunctionObject *
 _PyFunction_LookupByVersion(uint32_t version, PyObject **p_code)
 {
+#ifdef Py_GIL_DISABLED
+    return NULL;
+#else
     PyInterpreterState *interp = _PyInterpreterState_GET();
     struct _func_version_cache_item *slot =
         interp->func_state.func_version_cache
@@ -346,6 +355,7 @@ _PyFunction_LookupByVersion(uint32_t version, PyObject **p_code)
         return slot->func;
     }
     return NULL;
+#endif
 }
 
 uint32_t
diff --git a/Tools/tsan/suppressions_free_threading.txt b/Tools/tsan/suppressions_free_threading.txt
@@ -15,7 +15,6 @@ race:_add_to_weak_set
 race:_in_weak_set
 race:_mi_heap_delayed_free_partial
 race:_PyEval_EvalFrameDefault
-race:_PyFunction_SetVersion
 race:_PyImport_AcquireLock
 race:_PyImport_ReleaseLock
 race:_PyInterpreterState_SetNotRunningMain

Original file line number	Diff line number	Diff line change
`@@ -287,6 +287,7 @@ functions is running.`
`287`	`287`	`void`
`288`	`288`	`_PyFunction_SetVersion(PyFunctionObject *func, uint32_t version)`
`289`	`289`	`{`
	`290`	`+#ifndef Py_GIL_DISABLED`
`290`	`291`	`PyInterpreterState *interp = _PyInterpreterState_GET();`
`291`	`292`	`if (func->func_version != 0) {`
`292`	`293`	`struct _func_version_cache_item *slot =`
`@@ -297,19 +298,23 @@ _PyFunction_SetVersion(PyFunctionObject *func, uint32_t version)`
`297`	`298`	`// Leave slot->code alone, there may be use for it.`
`298`	`299`	`}`
`299`	`300`	`}`
	`301`	`+#endif`
`300`	`302`	`func->func_version = version;`
	`303`	`+#ifndef Py_GIL_DISABLED`
`301`	`304`	`if (version != 0) {`
`302`	`305`	`struct _func_version_cache_item *slot =`
`303`	`306`	`interp->func_state.func_version_cache`
`304`	`307`	`+ (version % FUNC_VERSION_CACHE_SIZE);`
`305`	`308`	`slot->func = func;`
`306`	`309`	`slot->code = func->func_code;`
`307`	`310`	`}`
	`311`	`+#endif`
`308`	`312`	`}`
`309`	`313`
`310`	`314`	`void`
`311`	`315`	`_PyFunction_ClearCodeByVersion(uint32_t version)`
`312`	`316`	`{`
	`317`	`+#ifndef Py_GIL_DISABLED`
`313`	`318`	`PyInterpreterState *interp = _PyInterpreterState_GET();`
`314`	`319`	`struct _func_version_cache_item *slot =`
`315`	`320`	`interp->func_state.func_version_cache`
`@@ -322,11 +327,15 @@ _PyFunction_ClearCodeByVersion(uint32_t version)`
`322`	`327`	`slot->func = NULL;`
`323`	`328`	`}`
`324`	`329`	`}`
	`330`	`+#endif`
`325`	`331`	`}`
`326`	`332`
`327`	`333`	`PyFunctionObject *`
`328`	`334`	`_PyFunction_LookupByVersion(uint32_t version, PyObject **p_code)`
`329`	`335`	`{`
	`336`	`+#ifdef Py_GIL_DISABLED`
	`337`	`+ return NULL;`
	`338`	`+#else`
`330`	`339`	`PyInterpreterState *interp = _PyInterpreterState_GET();`
`331`	`340`	`struct _func_version_cache_item *slot =`
`332`	`341`	`interp->func_state.func_version_cache`
`@@ -346,6 +355,7 @@ _PyFunction_LookupByVersion(uint32_t version, PyObject **p_code)`
`346`	`355`	`return slot->func;`
`347`	`356`	`}`
`348`	`357`	`return NULL;`
	`358`	`+#endif`
`349`	`359`	`}`
`350`	`360`
`351`	`361`	`uint32_t`