Add cache generation tracking for main interpreter contexts

flush_imports now works correctly for all context types:
- Subinterpreter pool: slots marked stale and replaced
- OWN_GIL: each has own subinterpreter destroyed with context
- Main interpreter: cache generation checked on module access

Added unconditional import_cache_get_generation() and
import_cache_flush_generation() functions that work regardless
of subinterpreter support.

Author: benoitc

c_src/py_nif.c

@@ -4124,6 +4124,7 @@ static ERL_NIF_TERM nif_context_create(ErlNifEnv *env, int argc, const ERL_NIF_T
     ctx->globals = NULL;
     ctx->locals = NULL;
     ctx->module_cache = NULL;
+    ctx->cache_generation = 0;
 
     /* Create callback pipe for blocking callback responses */
     if (pipe(ctx->callback_pipe) < 0) {
@@ -4236,6 +4237,7 @@ static ERL_NIF_TERM nif_context_create(ErlNifEnv *env, int argc, const ERL_NIF_T
         ctx->globals = PyDict_New();
         ctx->locals = PyDict_New();
         ctx->module_cache = PyDict_New();
+        ctx->cache_generation = import_cache_get_generation();
 
         /* Import __builtins__ into globals */
         PyObject *builtins = PyEval_GetBuiltins();
@@ -4368,6 +4370,25 @@ static ERL_NIF_TERM nif_context_destroy(ErlNifEnv *env, int argc, const ERL_NIF_
  * Helper function - no mutex needed since context is process-owned.
  */
 static PyObject *context_get_module(py_context_t *ctx, const char *module_name) {
+    /* Check for stale cache (main interpreter contexts only) */
+    if (ctx->module_cache != NULL) {
+#ifdef HAVE_SUBINTERPRETERS
+        /* Pool-backed contexts get fresh interpreters on flush, so only check
+         * for non-pool contexts (main interpreter or OWN_GIL) */
+        bool is_main_interp = (ctx->pool_slot < 0 && !ctx->uses_own_gil);
+#else
+        bool is_main_interp = true;  /* All contexts use main interpreter */
+#endif
+        if (is_main_interp) {
+            uint64_t current_gen = import_cache_get_generation();
+            if (ctx->cache_generation != current_gen) {
+                /* Cache is stale - clear it and update generation */
+                PyDict_Clear(ctx->module_cache);
+                ctx->cache_generation = current_gen;
+            }
+        }
+    }
+
     /* Check cache first */
     if (ctx->module_cache != NULL) {
         PyObject *cached = PyDict_GetItemString(ctx->module_cache, module_name);
@@ -5103,12 +5124,11 @@ static ERL_NIF_TERM nif_subinterp_pool_flush_generation(ErlNifEnv *env, int argc
     (void)argc;
     (void)argv;
 
-#ifdef HAVE_SUBINTERPRETERS
-    uint64_t new_gen = subinterp_pool_flush_generation();
+    /* Use the unconditional version that works with or without subinterpreters.
+     * This increments the generation counter (used by main interpreter contexts)
+     * and also marks pool slots stale when subinterpreters are available. */
+    uint64_t new_gen = import_cache_flush_generation();
     return enif_make_tuple2(env, ATOM_OK, enif_make_uint64(env, new_gen));
-#else
-    return enif_make_tuple2(env, ATOM_OK, enif_make_uint64(env, 0));
-#endif
 }
 
 /**

c_src/py_nif.h

@@ -888,6 +888,9 @@ typedef struct {
 
     /** @brief Module cache (Dict: module_name -> PyModule) */
     PyObject *module_cache;
+
+    /** @brief Cache generation for staleness detection (main interpreter contexts) */
+    uint64_t cache_generation;
 } py_context_t;
 
 /* ============================================================================

c_src/py_subinterp_pool.c

@@ -540,4 +540,30 @@ uint64_t subinterp_pool_get_generation(void) {
     return atomic_load(&g_import_generation);
 }
 
+#else /* !HAVE_SUBINTERPRETERS */
+
+/* For systems without subinterpreter support, we still need the generation
+ * counter for main interpreter context cache invalidation */
+static _Atomic uint64_t g_import_generation_no_subinterp = 0;
+
 #endif /* HAVE_SUBINTERPRETERS */
+
+/* ============================================================================
+ * Unconditional generation functions (work with or without subinterpreters)
+ * ============================================================================ */
+
+uint64_t import_cache_get_generation(void) {
+#ifdef HAVE_SUBINTERPRETERS
+    return atomic_load(&g_import_generation);
+#else
+    return atomic_load(&g_import_generation_no_subinterp);
+#endif
+}
+
+uint64_t import_cache_flush_generation(void) {
+#ifdef HAVE_SUBINTERPRETERS
+    return subinterp_pool_flush_generation();
+#else
+    return atomic_fetch_add(&g_import_generation_no_subinterp, 1) + 1;
+#endif
+}

c_src/py_subinterp_pool.h

@@ -211,4 +211,24 @@ uint64_t subinterp_pool_get_generation(void);
 
 #endif /* HAVE_SUBINTERPRETERS */
 
+/**
+ * @brief Get the current import generation (always available)
+ *
+ * This function is available regardless of subinterpreter support.
+ * It's used by main interpreter contexts to detect cache staleness.
+ *
+ * @return Current generation number (0 if never flushed)
+ */
+uint64_t import_cache_get_generation(void);
+
+/**
+ * @brief Increment the import generation counter (always available)
+ *
+ * This function is available regardless of subinterpreter support.
+ * For systems with subinterpreters, it also marks pool slots stale.
+ *
+ * @return The new generation number
+ */
+uint64_t import_cache_flush_generation(void);
+
 #endif /* PY_SUBINTERP_POOL_H */