Remove jl_call_nogil and benchmark regions

Author: cjdoris

CHANGELOG.md

@@ -22,6 +22,7 @@
     to relinquish Python resources around yielding or blocking Julia code.
   * JuliaCall now relinquishes and restores Python resources automatically while running
     Julia code, including Python-to-Julia callbacks.
+  * Removed JuliaCall's `jl_call_nogil` method; ordinary calls now provide its behavior.
   * Python-object finalizers no longer attach a Python thread state. Pending decrefs are
     queued until a state is already attached or `PythonCall.GC.gc()` drains the queue.
 * Changes to `PythonCall.GC` (now more like `Base.GC`):

benchmark/benchmarks.jl

@@ -50,6 +50,49 @@ end
 SUITE["basic"]["@py"]["pydict"]["init"] = @benchmarkable test_atpy(Val(false))
 SUITE["basic"]["@py"]["pydict"]["pydel"] = @benchmarkable test_atpy(Val(true))
 
+function test_region_pythoncall(x, n)
+    ans = 0
+    for _ = 1:n
+        ans += pylen(x)
+    end
+    return ans
+end
+
+function test_region_pythoncall_outer(x, n)
+    @pyregion begin
+        ans = 0
+        for _ = 1:n
+            ans += pylen(x)
+        end
+        return ans
+    end
+end
+
+function test_region_capi(x, n)
+    @pyregion begin
+        ans = 0
+        for _ = 1:n
+            ans += PythonCall.C.PyObject_Length(x)
+        end
+        return ans
+    end
+end
+
+const REGION_BENCHMARK_LENGTH = 1000
+
+SUITE["region"]["pythoncall"] = @benchmarkable(
+    test_region_pythoncall(x, REGION_BENCHMARK_LENGTH),
+    setup=(x = pytuple((1, 2, 3))),
+)
+SUITE["region"]["pythoncall_outer"] = @benchmarkable(
+    test_region_pythoncall_outer(x, REGION_BENCHMARK_LENGTH),
+    setup=(x = pytuple((1, 2, 3))),
+)
+SUITE["region"]["capi_outer"] = @benchmarkable(
+    test_region_capi(x, REGION_BENCHMARK_LENGTH),
+    setup=(x = pytuple((1, 2, 3))),
+)
+
 
 include("gcbench.jl")
 using .GCBench: append_lots

docs/src/juliacall-reference.md

@@ -70,8 +70,6 @@ and ending with `__` (since these are Python special methods) or starting with `
 - `jl_callback(*args, **kwargs)`: Calls the Julia object with the given arguments.
   Unlike ordinary calling syntax, the arguments are passed as `Py` objects instead of
   being converted.
-- `jl_call_nogil(*args, **kwargs)`: Compatibility spelling for an ordinary call. Python
-  resources are relinquished automatically while Julia code runs.
 - `jl_display()`: Display the object using Julia's display mechanism.
 - `jl_eval(expr)`: If the object is a Julia `Module`, evaluates the given expression.
 - `jl_help()`: Display help for the object.

docs/src/juliacall.md

@@ -171,6 +171,24 @@ PythonCall operations nested inside Julia callbacks are safe without explicit re
 
 You can also use [multi-threading from Julia](@ref jl-multi-threading).
 
+### Caveat: Julia's task scheduler
+
+If you use a Julia function which yields to the task scheduler, such as `sleep` instead of
+`Libc.systemsleep` in the example above, the Python thread waiting for the futures must
+periodically yield to Julia so that the Julia tasks can finish:
+
+```python
+jl_yield = getattr(jl, "yield")
+while True:
+  jl_yield()
+  state = wait(fs, timeout=0.1)
+  if not state.not_done:
+    break
+```
+
+This scheduler requirement is independent of Python thread-state management; ordinary
+JuliaCall calls still relinquish and restore Python resources automatically.
+
 ### [Caveat: Signal handling](@id py-multi-threading-signal-handling)
 
 We recommend setting [`PYTHON_JULIACALL_HANDLE_SIGNALS=yes`](@ref julia-config)

docs/src/v1-migration-guide.md

@@ -117,9 +117,8 @@ The outer `@pyregion` can also be omitted; the PythonCall operations remain corr
 `wait(event)` then needs no annotation. Both macros nest safely.
 
 JuliaCall similarly relinquishes Python resources automatically while arbitrary Julia code
-runs. Ordinary calls should be used instead of the old `_jl_call_nogil` spelling. The v1
-`jl_call_nogil` method remains available for compatibility but behaves like an ordinary
-call.
+runs. The `_jl_call_nogil` and `jl_call_nogil` methods have been removed; use an ordinary
+call instead.
 
 Finalizers no longer attach a Python thread state and block waiting for Python. If prompt
 cleanup matters, call `PythonCall.GC.gc()` at a suitable point to drain queued decrefs.

pytest/test_all.py

@@ -113,20 +113,20 @@ def test_julia_gc():
 
 
 @pytest.mark.parametrize("yld", [True, False])
-def test_call_nogil(yld):
-    """Tests that we can execute Julia code in parallel by releasing the GIL."""
+def test_parallel_call(yld):
+    """Tests that ordinary calls execute Julia code in parallel."""
     from concurrent.futures import ThreadPoolExecutor, wait
     from time import time
     from juliacall import Main as jl
 
-    # julia implementation of sleep which unlocks the GIL
+    # Julia implementations of sleep which do and do not yield.
     if yld:
         # use sleep, which yields
         jsleep = jl.sleep
     else:
         # use Libc.systemsleep which does not yield
         jsleep = jl.Libc.systemsleep
-    jsleep = jsleep.jl_call_nogil
+    assert not hasattr(jsleep, "jl_call_nogil")
     jyield = getattr(jl, "yield")
     # precompile
     jsleep(0.01)

src/JlWrap/any.jl

@@ -90,24 +90,6 @@ end
 pyjl_handle_error_type(::typeof(pyjlany_callback), self, exc::MethodError) =
     exc.f === self ? pybuiltins.TypeError : PyNULL
 
-function pyjlany_call_nogil(self, args_::Py, kwargs_::Py)
-    if pylen(kwargs_) > 0
-        args = pyconvert(Vector{Any}, args_)
-        kwargs = pyconvert(Dict{Symbol,Any}, kwargs_)
-        ans = pyjl(self(args...; kwargs...))
-    elseif pylen(args_) > 0
-        args = pyconvert(Vector{Any}, args_)
-        ans = pyjl(self(args...))
-    else
-        ans = pyjl(self())
-    end
-    unsafe_pydel(args_)
-    unsafe_pydel(kwargs_)
-    ans
-end
-pyjl_handle_error_type(::typeof(pyjlany_call_nogil), self, exc::MethodError) =
-    exc.f === self ? pybuiltins.TypeError : PyNULL
-
 function pyjlany_getitem(self, k_::Py)
     if self isa Type
         if pyistuple(k_)
@@ -607,10 +589,6 @@ class Jl(JlBase2):
         return self._jl_callmethod($(pyjl_methodnum(Py)))
     def jl_callback(self, *args, **kwargs):
         return self._jl_callmethod($(pyjl_methodnum(pyjlany_callback)), args, kwargs)
-    def jl_call_nogil(self, *args, **kwargs):
-        '''Compatibility alias for calling this Julia object. Python resources are
-        relinquished automatically while Julia code runs.'''
-        return self._jl_callmethod($(pyjl_methodnum(pyjlany_call_nogil)), args, kwargs)
     def _repr_mimebundle_(self, include=None, exclude=None):
         return self._jl_callmethod($(pyjl_methodnum(pyjlany_mimebundle)), include, exclude)
     @property