Remove SHARED_GIL subinterp pool (dead code after API simplification)

Since the API now only exposes worker mode, the SHARED_GIL subinterpreter
pool (py_subinterp_pool.c/h) is no longer reachable from user code.

Removed:
- c_src/py_subinterp_pool.c and .h
- All subinterp_pool references from py_nif.c and py_nif.h
- test/py_web_frameworks_SUITE.erl (tested removed py_asgi/py_wsgi)

The parallel pool (py_parallel_pool.c) remains for ENABLE_PARALLEL_PYTHON
builds which use OWN_GIL subinterpreters for true parallel execution.

Author: benoitc

c_src/py_nif.c

@@ -108,25 +108,8 @@ static void py_env_resource_dtor(ErlNifEnv *env, void *obj) {
     PyGILState_STATE gstate = PyGILState_Ensure();
 
 #ifdef HAVE_SUBINTERPRETERS
-    if (res->pool_slot >= 0) {
-        /* Created in a shared-GIL subinterpreter - must DECREF in correct interpreter */
-        subinterp_slot_t *slot = subinterp_pool_get(res->pool_slot);
-
-        /* Verify slot is still valid and has same interpreter */
-        if (slot != NULL && slot->initialized && slot->interp != NULL) {
-            int64_t slot_interp_id = PyInterpreterState_GetID(slot->interp);
-            if (slot_interp_id == res->interp_id) {
-                /* Same interpreter, safe to DECREF */
-                PyThreadState *saved = PyThreadState_Swap(slot->tstate);
-                Py_XDECREF(res->globals);
-                Py_XDECREF(res->locals);
-                PyThreadState_Swap(saved);
-            }
-            /* If interp_id mismatch, slot was reused - skip DECREF */
-        }
-        /* If slot invalid/not initialized, interpreter destroyed - skip DECREF */
-    } else if (res->interp_id != 0) {
-        /* OWN_GIL subinterpreter: pool_slot == -1 but interp_id != 0
+    if (res->interp_id != 0) {
+        /* OWN_GIL subinterpreter: interp_id != 0
          * These dicts were created in an OWN_GIL interpreter. We cannot safely
          * DECREF them here because:
          * 1. The interpreter might already be destroyed
@@ -290,7 +273,6 @@ static int is_inline_schedule_marker(PyObject *obj);
 #include "py_event_loop.c"
 #include "py_worker_pool.h"
 #include "py_worker_pool.c"
-#include "py_subinterp_pool.c"
 #include "py_subinterp_thread.c"
 #include "py_parallel_pool.c"
 #include "py_reactor_buffer.c"
@@ -441,38 +423,6 @@ static void context_destructor(ErlNifEnv *env, void *obj) {
     }
 #endif
 
-#ifdef HAVE_SUBINTERPRETERS
-#ifndef ENABLE_PARALLEL_PYTHON
-    /* For subinterpreter mode: clean up context's own dictionaries and release pool slot */
-    if (ctx->is_subinterp && ctx->pool_slot >= 0) {
-        /* Clean up Python objects with GIL */
-        if (runtime_is_running()) {
-            subinterp_slot_t *slot = subinterp_pool_get(ctx->pool_slot);
-            if (slot != NULL && slot->initialized) {
-                PyGILState_STATE gstate = PyGILState_Ensure();
-                PyThreadState *saved = PyThreadState_Swap(slot->tstate);
-
-                Py_XDECREF(ctx->module_cache);
-                Py_XDECREF(ctx->globals);
-                Py_XDECREF(ctx->locals);
-
-                PyThreadState_Swap(saved);
-                PyGILState_Release(gstate);
-            }
-        }
-        ctx->module_cache = NULL;
-        ctx->globals = NULL;
-        ctx->locals = NULL;
-
-        subinterp_pool_free(ctx->pool_slot);
-        ctx->pool_slot = -1;
-        ctx->destroyed = true;
-        atomic_fetch_add(&g_counters.ctx_destroyed, 1);
-        return;
-    }
-#endif /* !ENABLE_PARALLEL_PYTHON */
-#endif /* HAVE_SUBINTERPRETERS */
-
     if (!runtime_is_running()) {
         return;
     }
@@ -1224,37 +1174,6 @@ static ERL_NIF_TERM nif_py_init(ErlNifEnv *env, int argc, const ERL_NIF_TERM arg
     /* Save main thread state and release GIL for other threads */
     g_main_thread_state = PyEval_SaveThread();
 
-    /* Initialize subinterpreter pool (Python 3.12+) before starting executors */
-#ifdef HAVE_SUBINTERPRETERS
-#ifndef ENABLE_PARALLEL_PYTHON
-    /* Only init shared-GIL pool if not in parallel mode */
-    {
-        int pool_size = DEFAULT_POOL_SIZE;  /* Default pool size */
-        /* Check for config */
-        if (argc > 0 && enif_is_map(env, argv[0])) {
-            ERL_NIF_TERM key = enif_make_atom(env, "pool_size");
-            ERL_NIF_TERM value;
-            if (enif_get_map_value(env, argv[0], key, &value)) {
-                enif_get_int(env, value, &pool_size);
-            }
-        }
-
-        /* Restore GIL temporarily to create subinterpreters */
-        PyEval_RestoreThread(g_main_thread_state);
-        int pool_result = subinterp_pool_init(pool_size);
-        g_main_thread_state = PyEval_SaveThread();
-
-        if (pool_result < 0) {
-            PyEval_RestoreThread(g_main_thread_state);
-            g_main_thread_state = NULL;
-            Py_Finalize();
-            atomic_store(&g_runtime_state, PY_STATE_STOPPED);
-            return make_error(env, "subinterp_pool_init_failed");
-        }
-    }
-#endif /* !ENABLE_PARALLEL_PYTHON */
-#endif /* HAVE_SUBINTERPRETERS */
-
     /* Initialize parallel OWN_GIL pool (Python 3.14+) */
 #ifdef ENABLE_PARALLEL_PYTHON
     {
@@ -1402,19 +1321,12 @@ static ERL_NIF_TERM nif_finalize(ErlNifEnv *env, int argc, const ERL_NIF_TERM ar
         Py_XDECREF(g_numpy_ndarray_type);
         g_numpy_ndarray_type = NULL;
 
-#ifdef HAVE_SUBINTERPRETERS
-        /* Step 4: Shutdown subinterpreter pool - must be done with GIL held */
-        subinterp_pool_shutdown();
-#endif
         g_main_thread_state = PyEval_SaveThread();
     } else {
         /* Fallback to PyGILState if no main thread state saved */
         PyGILState_STATE gstate = PyGILState_Ensure();
         Py_XDECREF(g_numpy_ndarray_type);
         g_numpy_ndarray_type = NULL;
-#ifdef HAVE_SUBINTERPRETERS
-        subinterp_pool_shutdown();
-#endif
         PyGILState_Release(gstate);
     }
 #endif
@@ -4231,92 +4143,10 @@ static ERL_NIF_TERM nif_context_create(ErlNifEnv *env, int argc, const ERL_NIF_T
     }
     /* Fall through to worker mode for non-subinterp requests in parallel build */
 #endif /* ENABLE_PARALLEL_PYTHON */
-
-#ifndef ENABLE_PARALLEL_PYTHON
-    if (use_owngil) {
-        /* OWN_GIL mode: create dedicated pthread with OWN_GIL subinterpreter */
-        if (owngil_context_init(ctx) != 0) {
-            close(ctx->callback_pipe[0]);
-            close(ctx->callback_pipe[1]);
-            enif_release_resource(ctx);
-            return make_error(env, "owngil_init_failed");
-        }
-
-        ERL_NIF_TERM ref = enif_make_resource(env, ctx);
-        enif_release_resource(ctx);
-        atomic_fetch_add(&g_counters.ctx_created, 1);
-        return enif_make_tuple3(env, ATOM_OK, ref, enif_make_uint(env, ctx->interp_id));
-    } else if (use_subinterp) {
-        /* Allocate a slot from the subinterpreter pool */
-        int slot = subinterp_pool_alloc();
-        if (slot < 0) {
-            close(ctx->callback_pipe[0]);
-            close(ctx->callback_pipe[1]);
-            enif_release_resource(ctx);
-            return make_error(env, "pool_exhausted");
-        }
-
-        ctx->pool_slot = slot;
-
-        /* Get the pool slot for interpreter access */
-        subinterp_slot_t *pool_slot = subinterp_pool_get(slot);
-        if (pool_slot == NULL || !pool_slot->initialized) {
-            subinterp_pool_free(slot);
-            close(ctx->callback_pipe[0]);
-            close(ctx->callback_pipe[1]);
-            enif_release_resource(ctx);
-            return make_error(env, "pool_slot_invalid");
-        }
-
-        /* Create context's own namespace dictionaries.
-         * Each context needs its own globals/locals for isolation,
-         * even though they share the interpreter. */
-        PyGILState_STATE gstate = PyGILState_Ensure();
-        PyThreadState *saved = PyThreadState_Swap(pool_slot->tstate);
-
-        ctx->globals = PyDict_New();
-        ctx->locals = PyDict_New();
-        ctx->module_cache = PyDict_New();
-
-        if (ctx->globals == NULL || ctx->locals == NULL || ctx->module_cache == NULL) {
-            Py_XDECREF(ctx->globals);
-            Py_XDECREF(ctx->locals);
-            Py_XDECREF(ctx->module_cache);
-            PyThreadState_Swap(saved);
-            PyGILState_Release(gstate);
-            subinterp_pool_free(slot);
-            close(ctx->callback_pipe[0]);
-            close(ctx->callback_pipe[1]);
-            enif_release_resource(ctx);
-            return make_error(env, "dict_alloc_failed");
-        }
-
-        /* Import __builtins__ into globals */
-        PyObject *builtins = PyEval_GetBuiltins();
-        PyDict_SetItemString(ctx->globals, "__builtins__", builtins);
-
-        /* Import erlang module into globals */
-        PyObject *erlang_module = PyImport_ImportModule("erlang");
-        if (erlang_module != NULL) {
-            PyDict_SetItemString(ctx->globals, "erlang", erlang_module);
-            Py_DECREF(erlang_module);
-        } else {
-            PyErr_Clear();
-        }
-
-        PyThreadState_Swap(saved);
-        PyGILState_Release(gstate);
-
-#ifdef DEBUG
-        fprintf(stderr, "[NIF] Created context %u using pool slot %d with own namespace\n",
-                ctx->interp_id, slot);
-        fflush(stderr);
-#endif
-    } else
-#endif /* !ENABLE_PARALLEL_PYTHON */
 #else
-    /* Pre-3.12 Python - ignore subinterp mode request */
+    /* Pre-3.12 Python or non-parallel build - ignore subinterp mode request */
     (void)use_subinterp;
+    (void)use_owngil;
 #endif /* HAVE_SUBINTERPRETERS */
     {
         /* Worker mode - create a thread state in main interpreter */
@@ -4378,59 +4208,6 @@ static ERL_NIF_TERM nif_context_destroy(ErlNifEnv *env, int argc, const ERL_NIF_
     /* Mark as destroyed early to prevent new operations */
     ctx->destroyed = true;
 
-#ifdef HAVE_SUBINTERPRETERS
-#ifndef ENABLE_PARALLEL_PYTHON
-    /* OWN_GIL mode: shutdown the dedicated thread */
-    if (ctx->uses_own_gil) {
-        owngil_context_shutdown(ctx);
-        /* Close callback pipes */
-        if (ctx->callback_pipe[0] >= 0) {
-            close(ctx->callback_pipe[0]);
-            ctx->callback_pipe[0] = -1;
-        }
-        if (ctx->callback_pipe[1] >= 0) {
-            close(ctx->callback_pipe[1]);
-            ctx->callback_pipe[1] = -1;
-        }
-        atomic_fetch_add(&g_counters.ctx_destroyed, 1);
-        return ATOM_OK;
-    }
-#endif /* !ENABLE_PARALLEL_PYTHON */
-
-    if (ctx->is_subinterp && ctx->pool_slot >= 0) {
-        /* Clean up context's own namespace dictionaries */
-        if (runtime_is_running()) {
-            subinterp_slot_t *slot = subinterp_pool_get(ctx->pool_slot);
-            if (slot != NULL && slot->initialized) {
-                PyGILState_STATE gstate = PyGILState_Ensure();
-                PyThreadState *saved = PyThreadState_Swap(slot->tstate);
-
-                Py_XDECREF(ctx->module_cache);
-                Py_XDECREF(ctx->globals);
-                Py_XDECREF(ctx->locals);
-
-                PyThreadState_Swap(saved);
-                PyGILState_Release(gstate);
-            }
-        }
-        ctx->globals = NULL;
-        ctx->locals = NULL;
-        ctx->module_cache = NULL;
-
-        /* Release the pool slot back to the pool */
-        subinterp_pool_free(ctx->pool_slot);
-        ctx->pool_slot = -1;
-
-#ifdef DEBUG
-        fprintf(stderr, "[NIF] Destroyed context %u, released pool slot\n", ctx->interp_id);
-        fflush(stderr);
-#endif
-
-        atomic_fetch_add(&g_counters.ctx_destroyed, 1);
-        return ATOM_OK;
-    }
-#endif
-
     /* Worker mode - clean up Python objects with GIL */
     if (runtime_is_running()) {
         PyGILState_STATE gstate = PyGILState_Ensure();

c_src/py_nif.h

@@ -148,9 +148,6 @@ static inline PyObject *Py_NewRef(PyObject *o) {
 
 /** @} */
 
-/* Include subinterpreter pool header for shared-GIL pool model */
-#include "py_subinterp_pool.h"
-
 /* Include subinterpreter thread pool header for OWN_GIL parallelism */
 #include "py_subinterp_thread.h"
 
@@ -787,12 +784,11 @@ typedef struct {
  * - Mutex/condvar dispatch overhead
  * - Term copying between environments
  *
- * @note Python 3.12+ uses shared-GIL subinterpreters via pool slots
- * @note Older Python uses worker mode with main interpreter namespace
+ * @note With ENABLE_PARALLEL_PYTHON, uses OWN_GIL subinterpreters via parallel pool
+ * @note Otherwise uses worker mode with main interpreter namespace
  *
  * @see nif_context_create
  * @see nif_context_call
- * @see subinterp_pool_alloc
  */
 typedef struct {
     /** @brief Unique interpreter ID for routing (0 = main, >0 = subinterp) */
@@ -1051,27 +1047,6 @@ static inline py_context_guard_t py_context_acquire(py_context_t *ctx) {
     /* Acquire the GIL first (works for both modes) */
     guard.gstate = PyGILState_Ensure();
 
-#ifdef HAVE_SUBINTERPRETERS
-#ifndef ENABLE_PARALLEL_PYTHON
-    if (ctx->is_subinterp && ctx->pool_slot >= 0) {
-        /* Subinterpreter mode: swap to the pool slot's thread state */
-        subinterp_slot_t *slot = subinterp_pool_get(ctx->pool_slot);
-
-        if (slot == NULL || !slot->initialized) {
-            /* Pool slot invalid - release GIL and fail */
-            PyGILState_Release(guard.gstate);
-            return guard;
-        }
-
-        /* Swap to subinterpreter's thread state */
-        guard.saved_tstate = PyThreadState_Swap(slot->tstate);
-        guard.mode = PY_GUARD_SUBINTERP;
-        guard.acquired = true;
-        return guard;
-    }
-#endif /* !ENABLE_PARALLEL_PYTHON */
-#endif /* HAVE_SUBINTERPRETERS */
-
     /* Worker mode: just use the GIL we acquired */
     guard.mode = PY_GUARD_WORKER;
     guard.acquired = true;