Remove flush_imports - module unloading not supported

Removed flush_imports/0 and all related flush functionality:
- py:flush_imports/0
- py_context:flush_imports/2
- py_nif:interp_flush_imports/2
- py_nif:subinterp_pool_flush_generation/0
- Cache generation tracking in py_context_t

Import caching via py:import/1,2 remains fully functional.
Module imports are cached per-interpreter and persist for the
lifetime of the interpreter.

Author: benoitc

c_src/py_nif.c

@@ -3224,43 +3224,6 @@ static void owngil_execute_apply_imports(py_context_t *ctx) {
     ctx->response_ok = true;
 }
 
-/**
- * @brief Execute flush_imports in OWN_GIL context
- *
- * Clears the per-context module cache optimization layer.
- * Does NOT clear sys.modules (that would break Python).
- */
-static void owngil_execute_flush_imports(py_context_t *ctx) {
-    /* Remove specified modules from sys.modules */
-    PyObject *sys_modules = PyImport_GetModuleDict();  /* Borrowed ref */
-    if (sys_modules != NULL) {
-        ERL_NIF_TERM head, tail = ctx->request_data;
-        while (enif_get_list_cell(ctx->shared_env, tail, &head, &tail)) {
-            ErlNifBinary mod_bin;
-            if (enif_inspect_binary(ctx->shared_env, head, &mod_bin)) {
-                char *mod_name = enif_alloc(mod_bin.size + 1);
-                if (mod_name != NULL) {
-                    memcpy(mod_name, mod_bin.data, mod_bin.size);
-                    mod_name[mod_bin.size] = '\0';
-                    /* Remove module from sys.modules if present */
-                    if (PyDict_GetItemString(sys_modules, mod_name) != NULL) {
-                        PyDict_DelItemString(sys_modules, mod_name);
-                    }
-                    enif_free(mod_name);
-                }
-            }
-        }
-    }
-
-    /* Clear the per-context optimization cache if it exists */
-    if (ctx->module_cache != NULL) {
-        PyDict_Clear(ctx->module_cache);
-    }
-
-    ctx->response_term = enif_make_atom(ctx->shared_env, "ok");
-    ctx->response_ok = true;
-}
-
 /**
  * @brief Execute a request based on its type
  */
@@ -3299,9 +3262,6 @@ static void owngil_execute_request(py_context_t *ctx) {
         case CTX_REQ_APPLY_IMPORTS:
             owngil_execute_apply_imports(ctx);
             break;
-        case CTX_REQ_FLUSH_IMPORTS:
-            owngil_execute_flush_imports(ctx);
-            break;
         default:
             ctx->response_term = enif_make_tuple2(ctx->shared_env,
                 enif_make_atom(ctx->shared_env, "error"),
@@ -3911,50 +3871,6 @@ static ERL_NIF_TERM dispatch_apply_imports_to_owngil(
     return result;
 }
 
-/**
- * @brief Dispatch flush_imports to OWN_GIL worker thread
- *
- * @param env NIF environment
- * @param ctx Context resource
- * @param modules_list List of module names to remove from sys.modules
- * @return ok
- */
-static ERL_NIF_TERM dispatch_flush_imports_to_owngil(
-    ErlNifEnv *env, py_context_t *ctx, ERL_NIF_TERM modules_list
-) {
-    if (!atomic_load(&ctx->thread_running)) {
-        return make_error(env, "thread_not_running");
-    }
-
-    pthread_mutex_lock(&ctx->request_mutex);
-
-    enif_clear_env(ctx->shared_env);
-    ctx->request_type = CTX_REQ_FLUSH_IMPORTS;
-    ctx->request_data = enif_make_copy(ctx->shared_env, modules_list);
-
-    pthread_cond_signal(&ctx->request_ready);
-
-    /* Wait for response with timeout */
-    struct timespec deadline;
-    clock_gettime(CLOCK_REALTIME, &deadline);
-    deadline.tv_sec += OWNGIL_DISPATCH_TIMEOUT_SECS;
-
-    while (ctx->request_type != CTX_REQ_NONE) {
-        int rc = pthread_cond_timedwait(&ctx->response_ready, &ctx->request_mutex, &deadline);
-        if (rc == ETIMEDOUT) {
-            atomic_store(&ctx->thread_running, false);
-            pthread_mutex_unlock(&ctx->request_mutex);
-            fprintf(stderr, "OWN_GIL flush_imports dispatch timeout: worker thread unresponsive\n");
-            return make_error(env, "worker_timeout");
-        }
-    }
-
-    ERL_NIF_TERM result = enif_make_copy(env, ctx->response_term);
-    pthread_mutex_unlock(&ctx->request_mutex);
-
-    return result;
-}
-
 #endif /* HAVE_SUBINTERPRETERS */
 
 /**
@@ -4124,7 +4040,6 @@ 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) {
@@ -4237,7 +4152,6 @@ 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();
@@ -4370,25 +4284,6 @@ 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);
@@ -5040,97 +4935,6 @@ static ERL_NIF_TERM nif_interp_apply_imports(ErlNifEnv *env, int argc, const ERL
     return ATOM_OK;
 }
 
-/**
- * @brief Flush imports from an interpreter's sys.modules
- *
- * nif_interp_flush_imports(Ref, Modules) -> ok
- *
- * Removes specified modules from sys.modules and clears the per-context
- * module_cache optimization layer.
- *
- * @param Ref Context reference
- * @param Modules List of binary module names to remove from sys.modules
- */
-static ERL_NIF_TERM nif_interp_flush_imports(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
-    (void)argc;
-    py_context_t *ctx;
-
-    if (!runtime_is_running()) {
-        return ATOM_OK;  /* Nothing to flush if Python not running */
-    }
-
-    if (!enif_get_resource(env, argv[0], PY_CONTEXT_RESOURCE_TYPE, (void **)&ctx)) {
-        return make_error(env, "invalid_context");
-    }
-
-    if (ctx->destroyed) {
-        return ATOM_OK;  /* Already destroyed */
-    }
-
-#ifdef HAVE_SUBINTERPRETERS
-    /* OWN_GIL mode: dispatch to the dedicated thread */
-    if (ctx->uses_own_gil) {
-        return dispatch_flush_imports_to_owngil(env, ctx, argv[1]);
-    }
-#endif
-
-    py_context_guard_t guard = py_context_acquire(ctx);
-    if (!guard.acquired) {
-        return ATOM_OK;  /* Can't acquire - just return ok */
-    }
-
-    /* Remove specified modules from sys.modules */
-    PyObject *sys_modules = PyImport_GetModuleDict();  /* Borrowed ref */
-    if (sys_modules != NULL) {
-        ERL_NIF_TERM head, tail = argv[1];
-        while (enif_get_list_cell(env, tail, &head, &tail)) {
-            ErlNifBinary mod_bin;
-            if (enif_inspect_binary(env, head, &mod_bin)) {
-                char *mod_name = binary_to_string(&mod_bin);
-                if (mod_name != NULL) {
-                    /* Remove module from sys.modules if present */
-                    if (PyDict_GetItemString(sys_modules, mod_name) != NULL) {
-                        PyDict_DelItemString(sys_modules, mod_name);
-                    }
-                    enif_free(mod_name);
-                }
-            }
-        }
-    }
-
-    /* Clear per-context optimization cache */
-    if (ctx->module_cache != NULL) {
-        PyDict_Clear(ctx->module_cache);
-    }
-
-    py_context_release(&guard);
-    return ATOM_OK;
-}
-
-/**
- * @brief Flush import generation and mark all pool slots stale
- *
- * nif_subinterp_pool_flush_generation() -> {ok, NewGeneration}
- *
- * Increments the global import generation counter and marks all initialized
- * pool slots as stale. When a stale slot's usage count drops to 0, the
- * subinterpreter is automatically destroyed and the slot becomes available
- * for a fresh subinterpreter.
- *
- * This enables flush_imports to work by replacing subinterpreters rather
- * than trying to manipulate sys.modules directly (which can crash C extensions).
- */
-static ERL_NIF_TERM nif_subinterp_pool_flush_generation(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
-    (void)argc;
-    (void)argv;
-
-    /* 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));
-}
-
 /**
  * @brief Execute Python statements using a process-local environment
  *
@@ -7261,8 +7065,6 @@ static ErlNifFunc nif_funcs[] = {
     {"context_call", 6, nif_context_call_with_env, ERL_NIF_DIRTY_JOB_CPU_BOUND},
     {"create_local_env", 1, nif_create_local_env, 0},
     {"interp_apply_imports", 2, nif_interp_apply_imports, ERL_NIF_DIRTY_JOB_CPU_BOUND},
-    {"interp_flush_imports", 2, nif_interp_flush_imports, ERL_NIF_DIRTY_JOB_CPU_BOUND},
-    {"subinterp_pool_flush_generation", 0, nif_subinterp_pool_flush_generation, 0},
     {"context_call_method", 4, nif_context_call_method, ERL_NIF_DIRTY_JOB_CPU_BOUND},
     {"context_to_term", 1, nif_context_to_term, 0},
     {"context_interp_id", 1, nif_context_interp_id, 0},

c_src/py_nif.h

@@ -731,8 +731,7 @@ typedef enum {
     CTX_REQ_EVAL_WITH_ENV,      /**< Eval with process-local environment */
     CTX_REQ_EXEC_WITH_ENV,      /**< Exec with process-local environment */
     CTX_REQ_CREATE_LOCAL_ENV,   /**< Create process-local env dicts */
-    CTX_REQ_APPLY_IMPORTS,      /**< Apply imports to module cache */
-    CTX_REQ_FLUSH_IMPORTS       /**< Flush module cache */
+    CTX_REQ_APPLY_IMPORTS       /**< Apply imports to module cache */
 } ctx_request_type_t;
 
 /**
@@ -888,9 +887,6 @@ 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,30 +540,4 @@ 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,24 +211,4 @@ 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 */

src/py.erl

@@ -59,7 +59,6 @@
     %% Module import caching
     import/1,
     import/2,
-    flush_imports/0,
     import_stats/0,
     import_list/0,
     %% Import registry (global list applied to all interpreters)
@@ -462,27 +461,6 @@ clear_imports() ->
     end,
     ok.
 
-%% @doc Flush import caches and trigger subinterpreter replacement.
-%%
-%% Clears the global import registry and marks all shared-GIL pool
-%% subinterpreters as stale. When existing contexts using those
-%% subinterpreters are destroyed, Python GC handles cleanup via
-%% Py_EndInterpreter. New contexts will get fresh subinterpreters
-%% with the updated import registry.
-%%
-%% OWN_GIL contexts each have their own subinterpreter which is
-%% destroyed when the context is destroyed.
-%%
-%% @returns ok
--spec flush_imports() -> ok.
-flush_imports() ->
-    %% Clear the global registry
-    clear_imports(),
-    %% Mark all pool slots as stale - they will be destroyed when
-    %% usage count drops to 0 (all contexts using them are destroyed)
-    py_nif:subinterp_pool_flush_generation(),
-    ok.
-
 %% @doc Get import registry statistics.
 %%
 %% Returns a map with the count of registered imports.