Move value_cache, value_indices, and type_index_offset into ModuleState

Summary:
Move the `value_cache`, `value_indices`, and `type_index_offset` file-scope
globals from `StaticPython/classloader.c` into the `ModuleState` class. The
Python objects (`value_cache`, `value_indices`) are stored as `Ref<>` members
with proper GC traversal.

C accessor functions are provided in `module_c_state.h/cpp` for use from the
C code in `classloader.c`.

Reviewed By: jbower-fb

Differential Revision: D96742325

fbshipit-source-id: 7759165fa1959a3ec7c649fa7acc88ebc04cf8c0

Author: alexmalyshev

cinderx/StaticPython/classloader.c

@@ -913,43 +913,42 @@ void* _PyClassloader_LookupSymbol(PyObject* lib_name, PyObject* symbol_name) {
 }
 #endif
 
-// Python list used to cache values
-static PyObject* value_cache;
-// Dictionary of cached object -> index
-static PyObject* value_indices;
-// Current offset for type cache. When the type cache is cleared this
-// gets incremented by the current size so that we don't reuse previous
-// slots and any existing caches will fail.
-static int32_t type_index_offset;
-
 void _PyClassLoader_ClearValueCache() {
-  if (value_cache == NULL) {
+  PyObject* vc = Ci_GetValueCache();
+  if (vc == NULL) {
     return;
   }
-  type_index_offset += PyList_Size(value_cache);
-  Py_CLEAR(value_cache);
-  Py_CLEAR(value_indices);
+  Ci_AddTypeIndexOffset(PyList_Size(vc));
+  Ci_ClearValueCache();
+  Ci_ClearValueIndices();
 }
 
 int32_t _PyClassLoader_CacheValue(PyObject* value) {
-  if (value_cache == NULL) {
-    value_cache = PyList_New(0);
-    if (value_cache == NULL) {
+  PyObject* vc = Ci_GetValueCache();
+  if (vc == NULL) {
+    vc = PyList_New(0);
+    if (vc == NULL) {
       return -1;
     }
+    Ci_SetValueCache((PyListObject*)vc);
+    Py_DECREF(vc);
   }
-  if (value_indices == NULL) {
-    value_indices = PyDict_New();
-    if (value_indices == NULL) {
+  PyObject* vi = Ci_GetValueIndices();
+  if (vi == NULL) {
+    vi = PyDict_New();
+    if (vi == NULL) {
       return -1;
     }
+    Ci_SetValueIndices((PyDictObject*)vi);
+    Py_DECREF(vi);
   }
-  PyObject* index = PyDict_GetItem(value_indices, (PyObject*)value);
+  PyObject* index = PyDict_GetItem(vi, (PyObject*)value);
   if (index != NULL) {
     return PyLong_AsLong(index);
   }
 
-  Py_ssize_t iindex = PyList_GET_SIZE(value_cache) + type_index_offset;
+  int32_t tio = Ci_GetTypeIndexOffset();
+  Py_ssize_t iindex = PyList_GET_SIZE(vc) + tio;
   if (iindex >= INT32_MAX) {
     return -1;
   }
@@ -959,13 +958,13 @@ int32_t _PyClassLoader_CacheValue(PyObject* value) {
     return -1;
   }
 
-  if (PyList_Append(value_cache, value) < 0) {
+  if (PyList_Append(vc, value) < 0) {
     Py_DECREF(pyindex);
     return -1;
   }
 
-  if (PyDict_SetItem(value_indices, value, pyindex) < 0) {
-    Py_SET_SIZE((PyVarObject*)value_cache, iindex - type_index_offset);
+  if (PyDict_SetItem(vi, value, pyindex) < 0) {
+    Py_SET_SIZE((PyVarObject*)vc, iindex - tio);
     Py_DECREF(pyindex);
     return -1;
   }
@@ -974,9 +973,11 @@ int32_t _PyClassLoader_CacheValue(PyObject* value) {
 }
 
 PyObject* _PyClassLoader_GetCachedValue(int32_t type) {
-  if (value_cache == NULL || type < type_index_offset) {
+  PyObject* vc = Ci_GetValueCache();
+  int32_t tio = Ci_GetTypeIndexOffset();
+  if (vc == NULL || type < tio) {
     return NULL;
   }
-  type -= type_index_offset;
-  return Py_XNewRef(PyList_GetItem(value_cache, type));
+  type -= tio;
+  return Py_XNewRef(PyList_GetItem(vc, type));
 }

cinderx/module_c_state.cpp

@@ -65,6 +65,44 @@ void Ci_ClearClassLoaderCacheModuleToKeys(void) {
   }
 }
 
+PyObject* Ci_GetValueCache(void) {
+  auto state = cinderx::getModuleState();
+  return state != nullptr ? state->value_cache.getObj() : nullptr;
+}
+
+void Ci_SetValueCache(PyListObject* cache) {
+  cinderx::getModuleState()->value_cache = Ref<PyListObject>::create(cache);
+}
+
+void Ci_ClearValueCache(void) {
+  if (auto state = cinderx::getModuleState(); state != nullptr) {
+    state->value_cache.reset();
+  }
+}
+
+PyObject* Ci_GetValueIndices(void) {
+  auto state = cinderx::getModuleState();
+  return state != nullptr ? state->value_indices.getObj() : nullptr;
+}
+
+void Ci_SetValueIndices(PyDictObject* indices) {
+  cinderx::getModuleState()->value_indices = Ref<PyDictObject>::create(indices);
+}
+
+void Ci_ClearValueIndices(void) {
+  if (auto state = cinderx::getModuleState(); state != nullptr) {
+    state->value_indices.reset();
+  }
+}
+
+int32_t Ci_GetTypeIndexOffset(void) {
+  return cinderx::getModuleState()->type_index_offset;
+}
+
+void Ci_AddTypeIndexOffset(int32_t offset) {
+  cinderx::getModuleState()->type_index_offset += offset;
+}
+
 int Ci_Watchers_WatchDict(PyObject* dict) {
   return cinderx::getModuleState()->watcher_state.watchDict(dict);
 }

cinderx/module_c_state.h

@@ -38,6 +38,20 @@ PyObject* Ci_GetClassLoaderCacheModuleToKeys(void);
 void Ci_SetClassLoaderCacheModuleToKeys(PyDictObject* cache);
 void Ci_ClearClassLoaderCacheModuleToKeys(void);
 
+// Value cache for adaptive interpreter.
+PyObject* Ci_GetValueCache(void);
+void Ci_SetValueCache(PyListObject* cache);
+void Ci_ClearValueCache(void);
+
+// Value-to-index mapping.
+PyObject* Ci_GetValueIndices(void);
+void Ci_SetValueIndices(PyDictObject* indices);
+void Ci_ClearValueIndices(void);
+
+// Type index offset for value cache.
+int32_t Ci_GetTypeIndexOffset(void);
+void Ci_AddTypeIndexOffset(int32_t offset);
+
 // WatcherState.
 
 int Ci_Watchers_WatchDict(PyObject* dict);

cinderx/module_state.cpp

@@ -17,6 +17,8 @@ int ModuleState::traverse(visitproc visit, void* arg) {
   Py_VISIT(genericinst_cache);
   Py_VISIT(classloader_cache);
   Py_VISIT(classloader_cache_module_to_keys);
+  Py_VISIT(value_cache);
+  Py_VISIT(value_indices);
   Py_VISIT(builtin_next);
   return 0;
 }
@@ -26,6 +28,8 @@ int ModuleState::clear() {
   genericinst_cache.reset();
   classloader_cache.reset();
   classloader_cache_module_to_keys.reset();
+  value_cache.reset();
+  value_indices.reset();
   sys_clear_caches.reset();
   builtin_next.reset();
   return 0;

cinderx/module_state.h

@@ -67,6 +67,15 @@ struct ModuleState {
   // Mapping from module name to classloader cache keys for that module.
   Ref<PyDictObject> classloader_cache_module_to_keys;
 
+  // Cache for Static Python primitive values (int/float/etc.) by type.
+  Ref<PyListObject> value_cache;
+
+  // Mapping from Static Python value types to their indices.
+  Ref<PyDictObject> value_indices;
+
+  // Running offset for assigning type indices to Static Python types.
+  int32_t type_index_offset{0};
+
   // 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).