Fix multiple sequential erlang.call() infinite loop

When Python code made multiple sequential erlang.call() invocations
in the same function, the replay mechanism only cached ONE result.
On replay, the second call found no cache hit and suspended again,
causing an infinite loop.

The fix adds a force_blocking flag that triggers when in replay context
(tl_current_suspended != NULL) but no cache hit occurred. This ensures
subsequent erlang.call() invocations use blocking pipe behavior instead
of suspending again.

- First erlang.call() in a function: suspends (frees dirty scheduler)
- Subsequent calls during replay: blocking pipe (scheduler already held)

Author: benoitc

CHANGELOG.md

@@ -26,6 +26,10 @@
 
 ### Fixed
 
+- **Multiple sequential erlang.call()** - Fixed infinite loop when Python code makes
+  multiple sequential `erlang.call()` invocations in the same function. The replay
+  mechanism now falls back to blocking pipe behavior for subsequent calls after the
+  first suspension, preventing the infinite replay loop.
 - **Memory safety in C NIF** - Fixed memory leaks and added NULL checks
   - `nif_async_worker_new`: msg_env now freed on pipe/thread creation failure
   - `multi_executor_stop`: shutdown requests now properly freed after join

c_src/py_callback.c

@@ -579,6 +579,16 @@ static PyObject *erlang_call_impl(PyObject *self, PyObject *args) {
         }
     }
 
+    /*
+     * FIX for multiple sequential erlang.call():
+     * If we're in replay context (tl_current_suspended != NULL) but didn't get
+     * a cache hit above, this is a SUBSEQUENT call (e.g., second erlang.call()
+     * in the same Python function). We MUST NOT suspend again - that would
+     * cause an infinite loop where replay always hits this second call.
+     * Instead, fall through to blocking pipe behavior for subsequent calls.
+     */
+    bool force_blocking = (tl_current_suspended != NULL);
+
     /* Build args list (remaining args) */
     PyObject *call_args = PyTuple_GetSlice(args, 1, nargs);
     if (call_args == NULL) {
@@ -590,8 +600,10 @@ static PyObject *erlang_call_impl(PyObject *self, PyObject *args) {
      * Suspension is only safe when the result will be directly examined by the
      * executor (PY_REQ_CALL or PY_REQ_EVAL). For PY_REQ_EXEC or nested Python
      * code, we must block and wait for the result.
+     *
+     * Also block if force_blocking is set (replay context with no cache hit).
      */
-    if (!tl_allow_suspension) {
+    if (!tl_allow_suspension || force_blocking) {
         /* Fall back to blocking behavior - send message and wait on pipe */
         ErlNifEnv *msg_env = enif_alloc_env();
         if (msg_env == NULL) {

examples/reentrant_demo.py

@@ -133,3 +133,27 @@ def nested_compute(n, depth):
 
     # Call Erlang which will call nested_compute(n+1, depth-1)
     return erlang.call('nested_step', n, depth)
+
+
+def compute_chain(x):
+    """
+    Compute a chain of operations using multiple sequential Erlang callbacks.
+
+    This function makes THREE sequential erlang.call() invocations:
+    1. add_ten(x) -> x + 10
+    2. multiply_by_two(step1) -> step1 * 2
+    3. subtract_five(step2) -> step2 - 5
+
+    This tests the nested suspension handling - each call suspends Python,
+    executes the Erlang callback, then resumes Python to continue to the
+    next call.
+
+    Example: compute_chain(5) -> ((5 + 10) * 2) - 5 = 25
+    """
+    import erlang
+
+    step1 = erlang.call('add_ten', x)           # x + 10
+    step2 = erlang.call('multiply_by_two', step1)  # (x + 10) * 2
+    step3 = erlang.call('subtract_five', step2)    # ((x + 10) * 2) - 5
+
+    return step3

test/py_reentrant_SUITE.erl

@@ -19,7 +19,8 @@
     test_nested_callbacks/1,
     test_callback_error_propagation/1,
     test_concurrent_reentrant/1,
-    test_callback_with_complex_types/1
+    test_callback_with_complex_types/1,
+    test_multiple_sequential_callbacks/1
 ]).
 
 all() ->
@@ -28,7 +29,8 @@ all() ->
         test_nested_callbacks,
         test_callback_error_propagation,
         test_concurrent_reentrant,
-        test_callback_with_complex_types
+        test_callback_with_complex_types,
+        test_multiple_sequential_callbacks
     ].
 
 init_per_suite(Config) ->
@@ -49,6 +51,9 @@ end_per_testcase(_TestCase, _Config) ->
     catch py:unregister_function(call_level),
     catch py:unregister_function(may_fail),
     catch py:unregister_function(transform),
+    catch py:unregister_function(add_ten),
+    catch py:unregister_function(multiply_by_two),
+    catch py:unregister_function(subtract_five),
     ok.
 
 %%% ============================================================================
@@ -192,3 +197,36 @@ test_callback_with_complex_types(_Config) ->
     } = Result,
 
     ok.
+
+%% @doc Test multiple sequential erlang.call() invocations in one Python function.
+%% This tests that the nested suspension handling works when Python makes
+%% multiple callbacks within a single function execution.
+test_multiple_sequential_callbacks(_Config) ->
+    %% Register three Erlang functions that will be called sequentially
+    py:register_function(add_ten, fun([X]) -> X + 10 end),
+    py:register_function(multiply_by_two, fun([X]) -> X * 2 end),
+    py:register_function(subtract_five, fun([X]) -> X - 5 end),
+
+    %% Use py:eval with a lambda that makes 3 sequential erlang.call() invocations.
+    %% Each call triggers a suspension/resume cycle, and the second/third calls
+    %% require the nested suspension fix to work correctly.
+    %%
+    %% The lambda pattern: (lambda x: subtract_five(multiply_by_two(add_ten(x))))(input)
+    %% This is a single expression that makes 3 sequential callbacks.
+
+    %% Test with x=5: ((5 + 10) * 2) - 5 = 25
+    Code1 = <<"(lambda erl: erl.call('subtract_five', erl.call('multiply_by_two', erl.call('add_ten', 5))))(__import__('erlang'))">>,
+    {ok, Result1} = py:eval(Code1),
+    25 = Result1,
+
+    %% Test with x=10: ((10 + 10) * 2) - 5 = 35
+    Code2 = <<"(lambda erl: erl.call('subtract_five', erl.call('multiply_by_two', erl.call('add_ten', 10))))(__import__('erlang'))">>,
+    {ok, Result2} = py:eval(Code2),
+    35 = Result2,
+
+    %% Test with x=0: ((0 + 10) * 2) - 5 = 15
+    Code3 = <<"(lambda erl: erl.call('subtract_five', erl.call('multiply_by_two', erl.call('add_ten', 0))))(__import__('erlang'))">>,
+    {ok, Result3} = py:eval(Code3),
+    15 = Result3,
+
+    ok.