Move genericinst_cache into ModuleState

Summary:
Move the `genericinst_cache` file-scope global from `StaticPython/generic_type.c`
into the `ModuleState` class as a `Ref<>` member with proper GC traversal.

C accessor functions `Ci_GetGenericInstCache()`, `Ci_SetGenericInstCache()`,
and `Ci_ClearGenericInstCache()` are provided in `module_c_state.h/cpp` for
use from C code.

Reviewed By: jbower-fb

Differential Revision: D96617792

fbshipit-source-id: 5553217897e93c3ff92cd049cda31db4cd736693

Author: alexmalyshev

cinderx/StaticPython/generic_type.c

@@ -6,15 +6,14 @@
 #include "cinderx/StaticPython/vtable.h"
 #include "cinderx/StaticPython/vtable_builder.h"
 #include "cinderx/UpstreamBorrow/borrowed.h"
+#include "cinderx/module_c_state.h"
 
 #if PY_VERSION_HEX < 0x030C0000
 #include "cinder/exports.h"
 #endif
 
-static PyObject* genericinst_cache;
-
 void _PyClassLoader_ClearGenericTypes() {
-  Py_CLEAR(genericinst_cache);
+  Ci_ClearGenericInstCache();
 }
 
 static PyObject* get_optional_type(PyObject* type) {
@@ -398,19 +397,22 @@ PyObject* _PyClassLoader_GetGenericInst(
     PyObject* type,
     PyObject** args,
     Py_ssize_t nargs) {
-  if (genericinst_cache == NULL) {
-    genericinst_cache = PyDict_New();
-    if (genericinst_cache == NULL) {
+  PyObject* cache = Ci_GetGenericInstCache();
+  if (cache == NULL) {
+    cache = PyDict_New();
+    if (cache == NULL) {
       return NULL;
     }
+    Ci_SetGenericInstCache((PyDictObject*)cache);
+    Py_DECREF(cache);
   }
 
   PyObject* key = gtd_make_key(type, args, nargs);
   if (key == NULL) {
     return NULL;
   }
 
-  PyObject* inst = PyDict_GetItem(genericinst_cache, key);
+  PyObject* inst = PyDict_GetItem(cache, key);
   if (inst != NULL) {
     Py_DECREF(key);
     Py_INCREF(inst);
@@ -442,7 +444,7 @@ PyObject* _PyClassLoader_GetGenericInst(
     }
   }
 
-  if (res == NULL || PyDict_SetItem(genericinst_cache, key, res)) {
+  if (res == NULL || PyDict_SetItem(cache, key, res)) {
     Py_XDECREF(res);
     Py_DECREF(key);
     return NULL;

cinderx/module_c_state.cpp

@@ -16,6 +16,22 @@ PyObject* Ci_GetStaticTypeError(void) {
   return state != nullptr ? state->static_type_error.getObj() : nullptr;
 }
 
+PyObject* Ci_GetGenericInstCache(void) {
+  auto state = cinderx::getModuleState();
+  return state != nullptr ? state->genericinst_cache.getObj() : nullptr;
+}
+
+void Ci_SetGenericInstCache(PyDictObject* cache) {
+  cinderx::getModuleState()->genericinst_cache =
+      Ref<PyDictObject>::create(cache);
+}
+
+void Ci_ClearGenericInstCache(void) {
+  if (auto state = cinderx::getModuleState(); state != nullptr) {
+    state->genericinst_cache.reset();
+  }
+}
+
 int Ci_Watchers_WatchDict(PyObject* dict) {
   return cinderx::getModuleState()->watcher_state.watchDict(dict);
 }

cinderx/module_c_state.h

@@ -23,6 +23,11 @@ extern vectorcallfunc Ci_PyFunction_Vectorcall;
 // Get the StaticTypeError exception type.
 PyObject* Ci_GetStaticTypeError(void);
 
+// Generic type instantiation cache.
+PyObject* Ci_GetGenericInstCache(void);
+void Ci_SetGenericInstCache(PyDictObject* cache);
+void Ci_ClearGenericInstCache(void);
+
 // WatcherState.
 
 int Ci_Watchers_WatchDict(PyObject* dict);

cinderx/module_state.cpp

@@ -14,12 +14,14 @@ ModuleState* s_cinderx_state;
 
 int ModuleState::traverse(visitproc visit, void* arg) {
   Py_VISIT(static_type_error);
+  Py_VISIT(genericinst_cache);
   Py_VISIT(builtin_next);
   return 0;
 }
 
 int ModuleState::clear() {
   static_type_error.reset();
+  genericinst_cache.reset();
   sys_clear_caches.reset();
   builtin_next.reset();
   return 0;

cinderx/module_state.h

@@ -58,6 +58,9 @@ struct ModuleState {
   // The cinderx.StaticTypeError exception type.
   Ref<PyTypeObject> static_type_error;
 
+  // Cache for generic type instantiations (e.g. list[int]).
+  Ref<PyDictObject> genericinst_cache;
+
   // Snapshotted member dicts for standard builtin types (int, str, list, etc.)
   // so the JIT optimizer can look up methods during multithreaded compilation
   // without calling PyType_Lookup (which isn't safe off the main thread).