ADDED: py_with_gil/1 and use the GIL in pl_call/1,2

Does deadlock.  Seems this could be related to python/cpython#96071

Author: JanWielemaker

janus.c

@@ -674,32 +674,39 @@ py_call(term_t Call, term_t result)
 { PyObject *py_target = NULL;
   term_t call = PL_copy_term_ref(Call);
   term_t on = PL_new_term_ref();
+  int rc = TRUE;
 
   if ( !py_init() )
     return FALSE;
 
+  PyGILState_STATE state = PyGILState_Ensure();
   while ( PL_is_functor(call, FUNCTOR_module2) )
   { _PL_get_arg(1, call, on);
     _PL_get_arg(2, call, call);
 
     if ( !py_target )
     { if ( !get_py_obj(on, &py_target, FALSE) &&
 	   !get_py_module(on, &py_target) )
-	return PL_type_error("py_target", on);
+      { rc = PL_type_error("py_target", on);
+	break;
+      }
       Py_INCREF(py_target);
     } else
     { if ( !(py_target = py_eval(py_target, on)) )
-	return FALSE;
+      { rc = FALSE;
+	break;
+      }
     }
   }
 
-  if ( !(py_target = py_eval(py_target, call)) )
-    return FALSE;
+  rc = rc && !!(py_target = py_eval(py_target, call));
 
-  if ( result )
-    return py_unify_decref(result, py_target);
-  else
-    return TRUE;
+  if ( rc && result )
+    rc = py_unify_decref(result, py_target);
+
+  PyGILState_Release(state);
+
+  return rc;
 }
 
 static foreign_t
@@ -708,6 +715,16 @@ py_call1(term_t Call)
 }
 
 
+static foreign_t
+py_with_gil(term_t goal)
+{ PyGILState_STATE state = PyGILState_Ensure();
+  int rc = PL_call(goal, NULL);
+  PyGILState_Release(state);
+
+  return rc;
+}
+
+
 static foreign_t
 py_str(term_t t, term_t str)
 { PyObject *obj;
@@ -750,6 +767,7 @@ install_janus(void)
   PL_register_foreign("py_initialize", 2, py_initialize, 0);
   PL_register_foreign("py_call",       2, py_call,       0);
   PL_register_foreign("py_call",       1, py_call1,      0);
+  PL_register_foreign("py_with_gil",   1, py_with_gil,   PL_FA_TRANSPARENT);
   PL_register_foreign("py_str",        2, py_str,        0);
 
   if ( PyImport_AppendInittab("swipl", PyInit_swipl) == -1 )

janus.pl

@@ -35,6 +35,7 @@
 :- module(janus,
           [ py_call/1,                  % +Call
             py_call/2,                  % +Call, -Return
+	    py_with_gil/1,		% :Goal
             py_str/2,                   % +Obj, -String
             py_initialize/2,            % +Program, +Argv
             py_lib_dirs/1,              % -Dirs
@@ -43,6 +44,7 @@
             py_shell/0
           ]).
 :- use_foreign_library(foreign(janus)).
+:- meta_predicate py_with_gil(0).
 
 :- public
     py_initialize/0,
@@ -111,6 +113,14 @@
 %       ?- py_call($Dog:tricks, Tricks).
 %       Tricks = ["roll_over"]
 
+%!  py_with_gil(:Goal) is semidet.
+%
+%   Run Goal as  once(Goal)  while  holding   the  Phyton  GIL  (_Global
+%   Interpreter Lock). Note that py_call/1,2 also   locks  the GIL. This
+%   predicate is only required if we  wish   to  make  multiple calls to
+%   Python while keeping the GIL. The GIL is a _recursive_ lock and thus
+%   calling py_call/1,2 while hilding the GIL does not _deadlock_.
+
 
 		 /*******************************
 		 *            INIT		*

tests/prolog.py

@@ -22,3 +22,10 @@ def bench_call(n):
 
 def echo(d):
     return d
+
+
+class Counter:
+    def __init__(self):
+        self.count = 0
+    def increment(self):
+        self.count += 1