Fix test failures after API simplification to worker mode

Remove subinterpreter-specific tests that are no longer applicable:
- py_context_process_SUITE: Remove subinterp test group
- py_channel_SUITE: Remove subinterp_sync_receive_wait_test
- py_import_SUITE: Remove registry_applied_to_subinterp_test
- py_reactor_SUITE: Remove reactor_context_subinterp_isolation_test

Fix parallel pool crash by properly restoring main interpreter state:
- Save main_tstate before creating OWN_GIL subinterpreters
- Use PyEval_RestoreThread(main_tstate) instead of PyGILState_Ensure()
- Defer event loop initialization to avoid NULL env parameter

All 415 tests pass in both standard and parallel modes.

Author: benoitc

c_src/py_parallel_pool.c

@@ -82,9 +82,10 @@ int parallel_pool_init(int size) {
     memset(g_parallel_pool, 0, sizeof(g_parallel_pool));
     atomic_store(&g_parallel_next_slot, 0);
 
-    /* Note: When creating OWN_GIL subinterpreters, the main GIL is released
-     * after each Py_NewInterpreterFromConfig call and we need to re-acquire
-     * it with PyGILState_Ensure() for the next iteration. */
+    /* Save the main thread state. We need to restore this after creating
+     * each OWN_GIL subinterpreter because Py_NewInterpreterFromConfig
+     * releases the main GIL and switches to the new subinterpreter. */
+    PyThreadState *main_tstate = PyThreadState_Get();
 
     for (int i = 0; i < size; i++) {
         parallel_slot_t *slot = &g_parallel_pool[i];
@@ -122,8 +123,8 @@ int parallel_pool_init(int size) {
                 }
             }
 
-            /* Try to restore main thread state */
-            PyGILState_Ensure();
+            /* Restore main thread state */
+            PyEval_RestoreThread(main_tstate);
             return -1;
         }
 
@@ -155,7 +156,8 @@ int parallel_pool_init(int size) {
                 }
             }
 
-            PyGILState_Ensure();
+            /* Restore main thread state */
+            PyEval_RestoreThread(main_tstate);
             return -1;
         }
 
@@ -189,23 +191,25 @@ int parallel_pool_init(int size) {
             }
         }
 
-        /* Initialize event loop for this subinterpreter */
-        if (init_subinterpreter_event_loop(NULL) < 0) {
-            fprintf(stderr, "parallel_pool_init: failed to init event loop in slot %d\n", i);
-            log_and_clear_python_error("parallel_pool event_loop_init");
-            /* Non-fatal - async features won't work */
-        }
+        /* Note: Event loop initialization is deferred until first use.
+         * The init_subinterpreter_event_loop() function requires an ErlNifEnv
+         * which we don't have during pool initialization. Event loops will be
+         * created lazily when async operations are first performed. */
 
         slot->initialized = true;
         atomic_store(&slot->active_count, 0);
         atomic_store(&slot->shutdown_requested, false);
 
         /* Release this slot's GIL (save thread state).
-         * After this, we need to re-acquire main GIL to create next subinterpreter. */
+         * After this, we need to restore the main thread state to create the
+         * next subinterpreter or to return to the caller. */
         PyEval_SaveThread();
 
-        /* Re-acquire main GIL for next iteration */
-        PyGILState_Ensure();
+        /* Restore main interpreter thread state for next iteration.
+         * This is critical: PyGILState_Ensure() doesn't work correctly after
+         * creating OWN_GIL subinterpreters because there's no thread state
+         * associated with the calling thread anymore. */
+        PyEval_RestoreThread(main_tstate);
     }
 
     g_parallel_pool_size = size;

c_src/py_subinterp_pool.c

@@ -187,13 +187,10 @@ int subinterp_pool_init(int size) {
             }
         }
 
-        /* Initialize event loop for this subinterpreter.
-         * This enables asyncio support (sleep, timers, etc.) */
-        if (init_subinterpreter_event_loop(NULL) < 0) {
-            fprintf(stderr, "subinterp_pool_init: failed to init event loop in subinterp %d\n", i);
-            log_and_clear_python_error("subinterp event_loop_init");
-            /* Non-fatal - async features just won't work */
-        }
+        /* Note: Event loop initialization is deferred until first use.
+         * The init_subinterpreter_event_loop() function requires an ErlNifEnv
+         * which we don't have during pool initialization. Event loops will be
+         * created lazily when async operations are first performed. */
 
         slot->initialized = true;
 

c_src/py_worker_pool.c

@@ -493,12 +493,10 @@ static void *py_pool_worker_thread(void *arg) {
 
         worker->interp = PyThreadState_GetInterpreter(worker->tstate);
 
-        /* Initialize event loop for this subinterpreter */
-        if (init_subinterpreter_event_loop(NULL) < 0) {
-            gil_release(guard);
-            worker->running = false;
-            return NULL;
-        }
+        /* Note: Event loop initialization is deferred until first use.
+         * The init_subinterpreter_event_loop() function requires an ErlNifEnv
+         * which we don't have during worker initialization. Event loops will be
+         * created lazily when async operations are first performed. */
 
         /* Release main GIL - we now have our own */
         gil_release(guard);

test/py_channel_SUITE.erl

@@ -42,8 +42,6 @@
     mixed_waiter_async_blocks_sync_test/1,
     %% Async receive with actual waiting
     async_receive_wait_e2e_test/1,
-    %% Subinterpreter mode tests
-    subinterp_sync_receive_wait_test/1,
     %% Close and drain tests
     close_drain_erlang_test/1,
     close_drain_python_sync_test/1,
@@ -80,8 +78,6 @@ all() -> [
     mixed_waiter_async_blocks_sync_test,
     %% Async receive with actual waiting
     async_receive_wait_e2e_test,
-    %% Subinterpreter mode tests
-    subinterp_sync_receive_wait_test,
     %% Close and drain tests
     close_drain_erlang_test,
     close_drain_python_sync_test,
@@ -551,71 +547,6 @@ async def receive_from_channel(ch_ref):
 
     ok = py_channel:close(Ch).
 
-%%% ============================================================================
-%%% Subinterpreter Mode Tests
-%%% ============================================================================
-
-%% @doc Test sync blocking receive works with subinterpreter mode contexts
-%% This is a true e2e test: Python Channel.receive() blocks until Erlang sends data
-subinterp_sync_receive_wait_test(_Config) ->
-    case py_nif:subinterp_supported() of
-        false ->
-            {skip, "Subinterpreters not supported (requires Python 3.12+)"};
-        true ->
-            do_subinterp_sync_receive_wait_test()
-    end.
-
-do_subinterp_sync_receive_wait_test() ->
-    {ok, Ch} = py_channel:new(),
-    Self = self(),
-
-    %% Create a context explicitly in subinterp mode
-    CtxId = erlang:unique_integer([positive]),
-    {ok, CtxPid} = py_context:start_link(CtxId, subinterp),
-
-    %% Import Channel class in the subinterp context
-    ok = py_context:exec(CtxPid, <<"from erlang import Channel">>),
-
-    %% Test 1: Immediate receive with data already available
-    ok = py_channel:send(Ch, <<"immediate_data">>),
-    {ok, <<"immediate_data">>} = py_context:eval(CtxPid,
-        <<"Channel(ch).receive()">>, #{<<"ch">> => Ch}),
-    ct:pal("Subinterp immediate receive OK"),
-
-    %% Test 2: Blocking receive - spawn process to send data after delay
-    spawn_link(fun() ->
-        timer:sleep(100),
-        ok = py_channel:send(Ch, <<"delayed_data">>),
-        Self ! data_sent
-    end),
-
-    %% This should block until the spawned process sends data
-    {ok, <<"delayed_data">>} = py_context:eval(CtxPid,
-        <<"Channel(ch).receive()">>, #{<<"ch">> => Ch}),
-    receive data_sent -> ok after 1000 -> ok end,
-    ct:pal("Subinterp blocking receive OK"),
-
-    %% Test 3: try_receive on empty channel returns None
-    {ok, none} = py_context:eval(CtxPid,
-        <<"Channel(ch).try_receive()">>, #{<<"ch">> => Ch}),
-    ct:pal("Subinterp try_receive empty OK"),
-
-    %% Test 4: Channel close detected by receive
-    ok = py_channel:close(Ch),
-    ok = py_context:exec(CtxPid, <<"
-def test_closed(ch_ref):
-    try:
-        Channel(ch_ref).receive()
-        return 'no_exception'
-    except:
-        return 'got_exception'
-">>),
-    {ok, <<"got_exception">>} = py_context:eval(CtxPid,
-        <<"test_closed(ch)">>, #{<<"ch">> => Ch}),
-    ct:pal("Subinterp closed channel detected OK"),
-
-    py_context:stop(CtxPid).
-
 %%% ============================================================================
 %%% Close and Drain Tests
 %%% ============================================================================

test/py_context_process_SUITE.erl

@@ -36,8 +36,7 @@
 
 all() ->
     [
-        {group, worker},
-        {group, subinterp}
+        {group, worker}
     ].
 
 groups() ->
@@ -56,8 +55,7 @@ groups() ->
         test_context_type_conversions
     ],
     [
-        {worker, [sequence], Tests},
-        {subinterp, [sequence], Tests}
+        {worker, [sequence], Tests}
     ].
 
 init_per_suite(Config) ->
@@ -69,14 +67,7 @@ end_per_suite(_Config) ->
     ok.
 
 init_per_group(worker, Config) ->
-    [{context_type, worker} | Config];
-init_per_group(subinterp, Config) ->
-    case py_nif:subinterp_supported() of
-        true ->
-            [{context_type, subinterp} | Config];
-        false ->
-            {skip, "Subinterpreters not supported (requires Python 3.12+)"}
-    end.
+    [{context_type, worker} | Config].
 
 end_per_group(_Group, _Config) ->
     ok.

test/py_import_SUITE.erl

@@ -36,7 +36,6 @@
     event_loop_pool_import_test/1,
     spawn_task_uses_import_test/1,
     subinterp_isolation_test/1,
-    registry_applied_to_subinterp_test/1,
     %% sys.modules verification tests
     import_in_sys_modules_test/1,
     registry_import_in_sys_modules_test/1,
@@ -78,7 +77,6 @@ groups() ->
         event_loop_pool_import_test,
         spawn_task_uses_import_test,
         subinterp_isolation_test,
-        registry_applied_to_subinterp_test,
         %% sys.modules verification tests
         import_in_sys_modules_test,
         registry_import_in_sys_modules_test,
@@ -589,34 +587,6 @@ subinterp_isolation_test(_Config) ->
             ct:pal("Subinterpreter isolation verified - different interpreters are isolated")
     end.
 
-%% @doc Test that registry imports are applied to new subinterpreter contexts
-%%
-%% When py:import is called, it adds to the registry. New contexts should
-%% have these imports applied to their interpreter.
-registry_applied_to_subinterp_test(_Config) ->
-    %% Skip if subinterpreters not supported
-    case py_nif:subinterp_supported() of
-        false ->
-            {skip, "Subinterpreters not supported"};
-        true ->
-            %% Clear registry and add an import
-            ok = py_import:clear_imports(),
-            ok = py_import:ensure_imported(uuid),
-
-            %% Create a new subinterp context
-            {ok, Ctx} = py_context:new(#{mode => subinterp}),
-
-            %% The uuid module should be available (applied from registry)
-            {ok, Result} = py_context:call(Ctx, uuid, uuid4, [], #{}),
-            ?assert(is_binary(Result) orelse is_list(Result)),
-
-            %% Clean up
-            py_context:destroy(Ctx),
-            ok = py_import:clear_imports(),
-
-            ct:pal("Registry imports successfully applied to new subinterpreter")
-    end.
-
 %% ============================================================================
 %% sys.modules Verification Tests
 %% ============================================================================