Merge pull request #91 from mrkn/without_gvl

Add PyCall.without_gvl

Author: mrkn

CHANGES.md

@@ -1,5 +1,9 @@
 # The change history of PyCall
 
+## master
+
+* Add `PyCall.without_gvl` for explicitly releasing the RubyVM GVL
+
 ## 1.2.1
 
 * Prevent circular require in pycall/iruby.rb

README.md

@@ -61,6 +61,24 @@ the `Math.sin` in Ruby:
 Type conversions from Ruby to Python are automatically performed for numeric,
 boolean, string, arrays, and hashes.
 
+### Releasing the RubyVM GVL during Python function calls
+
+You may want to release the RubyVM GVL when you call a Python function that takes very long runtime.
+PyCall provides `PyCall.without_gvl` method for such purpose.  When PyCall performs python function call,
+PyCall checks the current context, and then it releases the RubyVM GVL when the current context is in a `PyCall.without_gvl`'s block.
+
+```ruby
+PyCall.without_gvl do
+  # In this block, all Python function calls are performed without
+  # the GVL acquisition.
+  pyobj.long_running_function()
+end
+
+# Outside of PyCall.without_gvl block,
+# all Python function calls are performed with the GVL acquisition.
+pyobj.long_running_function()
+```
+
 ### Debugging python finder
 
 When you encounter `PyCall::PythonNotFound` error, you can investigate PyCall's python finder by setting `PYCALL_DEBUG_FIND_LIBPYTHON` environment variable to `1`.  You can see the log like below:

ext/pycall/pycall.c

@@ -70,6 +70,52 @@ pycall_after_fork(VALUE mod)
   return Qnil;
 }
 
+static volatile pycall_tls_key without_gvl_key;
+
+int
+pycall_without_gvl_p(void)
+{
+  /*
+   * In pthread, the default value is NULL (== 0).
+   *
+   * In Win32 thread, the default value is 0 (initialized by TlsAlloc).
+   */
+  return (int)pycall_tls_get(without_gvl_key);
+}
+
+static inline int
+pycall_set_without_gvl(void)
+{
+  return pycall_tls_set(without_gvl_key, (void *)1);
+}
+
+static inline int
+pycall_set_with_gvl(void)
+{
+  return pycall_tls_set(without_gvl_key, (void *)0);
+}
+
+VALUE
+pycall_without_gvl(VALUE (* func)(VALUE), VALUE arg)
+{
+  int state;
+  VALUE result;
+
+  pycall_set_without_gvl();
+
+  result = rb_protect(func, arg, &state);
+
+  pycall_set_with_gvl();
+
+  return result;
+}
+
+static VALUE
+pycall_m_without_gvl(VALUE mod)
+{
+  return pycall_without_gvl(rb_yield, Qnil);
+}
+
 /* ==== PyCall::PyPtr ==== */
 
 const rb_data_type_t pycall_pyptr_data_type = {
@@ -890,7 +936,7 @@ struct call_pyobject_call_params {
   PyObject *kwargs;
 };
 
-PyObject *
+static inline PyObject *
 call_pyobject_call(struct call_pyobject_call_params *params)
 {
   PyObject *res;
@@ -899,17 +945,22 @@ call_pyobject_call(struct call_pyobject_call_params *params)
 }
 
 PyObject *
-pyobject_call_without_gvl(PyObject *pycallable, PyObject *args, PyObject *kwargs)
+pyobject_call(PyObject *pycallable, PyObject *args, PyObject *kwargs)
 {
   PyObject *res;
   struct call_pyobject_call_params params;
   params.pycallable = pycallable;
   params.args = args;
   params.kwargs = kwargs;
 
-  res = (PyObject *)rb_thread_call_without_gvl(
-      (void * (*)(void *))call_pyobject_call, (void *)&params,
-      (rb_unblock_function_t *)pycall_interrupt_python_thread, NULL);
+  if (pycall_without_gvl_p()) {
+    res = (PyObject *)rb_thread_call_without_gvl(
+        (void * (*)(void *))call_pyobject_call, (void *)&params,
+        (rb_unblock_function_t *)pycall_interrupt_python_thread, NULL);
+  }
+  else {
+    res = call_pyobject_call(&params);
+  }
 
   return res;
 }
@@ -961,7 +1012,7 @@ pycall_call_python_callable(PyObject *pycallable, int argc, VALUE *argv)
     }
   }
 
-  res = pyobject_call_without_gvl(pycallable, args, kwargs); /* New reference */
+  res = pyobject_call(pycallable, args, kwargs); /* New reference */
   if (!res) {
     pycall_pyerror_fetch_and_raise("PyObject_Call in pycall_call_python_callable");
   }
@@ -2185,6 +2236,9 @@ Init_pycall(void)
 
   rb_define_module_function(mPyCall, "after_fork", pycall_after_fork, 0);
 
+  pycall_tls_create(&without_gvl_key);
+  rb_define_module_function(mPyCall, "without_gvl", pycall_m_without_gvl, 0);
+
   /* PyCall::PyPtr */
 
   cPyPtr = rb_define_class_under(mPyCall, "PyPtr", rb_cBasicObject);

ext/pycall/pycall_internal.h

@@ -11,10 +11,19 @@ extern "C" {
 #include <ruby.h>
 #include <ruby/encoding.h>
 #include <ruby/thread.h>
+
 #include <assert.h>
 #include <inttypes.h>
 #include <limits.h>
 
+#if defined(_WIN32)
+# define PYCALL_THREAD_WIN32
+# include <ruby/win32.h>
+#elif defined(HAVE_PTHREAD_H)
+# define PYCALL_THREAD_PTHREAD
+# include <pthread.h>
+#endif
+
 #if SIZEOF_LONG == SIZEOF_VOIDP
 # define PTR2NUM(x)   (LONG2NUM((long)(x)))
 # define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
@@ -492,6 +501,23 @@ extern PyTypeObject PyRuby_Type;
 
 PyObject * PyRuby_New(VALUE ruby_object);
 
+/* ==== thread support ==== */
+
+#if   defined(PYCALL_THREAD_WIN32)
+typedef DWORD pycall_tls_key;
+#elif defined(PYCALL_THREAD_PTHREAD)
+typedef pthread_key_t pycall_tls_key;
+#else
+# error "unsupported thread type"
+#endif
+
+int pycall_tls_create(pycall_tls_key* tls_key);
+void *pycall_tls_get(pycall_tls_key tls_key);
+int pycall_tls_set(pycall_tls_key tls_key, void *ptr);
+
+int pycall_without_gvl_p(void);
+VALUE pycall_without_gvl(VALUE (* func)(VALUE), VALUE arg);
+
 /* ==== pycall ==== */
 
 typedef struct {

ext/pycall/thread.c

@@ -0,0 +1,36 @@
+#include "pycall_internal.h"
+
+#if defined(PYCALL_THREAD_WIN32)
+int pycall_tls_create(pycall_tls_key *tls_key)
+{
+  *tls_key = TlsAlloc();
+  return *tls_key == TLS_OUT_OF_INDEXES;
+}
+
+void *pycall_tls_get(pycall_tls_key tls_key)
+{
+  return TlsGetValue(tls_key);
+}
+
+int pycall_tls_set(pycall_tls_key tls_key, void *ptr)
+{
+  return 0 == TlsSetValue(tls_key, ptr);
+}
+#endif
+
+#if defined(PYCALL_THREAD_PTHREAD)
+int pycall_tls_create(pycall_tls_key *tls_key)
+{
+  return pthread_key_create(tls_key, NULL);
+}
+
+void *pycall_tls_get(pycall_tls_key tls_key)
+{
+  return pthread_getspecific(tls_key);
+}
+
+int pycall_tls_set(pycall_tls_key tls_key, void *ptr)
+{
+  return pthread_setspecific(tls_key, ptr);
+}
+#endif

spec/pycall/gvl_spec.rb

@@ -1,36 +1,71 @@
 require 'spec_helper'
 
-::RSpec.describe PyCall do
-  it 'releases GVL during Python C API invocation' do
-    py_time = PyCall.import_module('time')
-
-    mutex = Mutex.new
-    cv = ConditionVariable.new
-    cancel = false
-    counter = Thread.start do
-      count = 0
-      mutex.synchronize do
-        until cancel
-          count += 1
-          cv.wait(mutex, 0.1)
+RSpec.describe PyCall do
+  context 'outside of PyCall.without_gvl' do
+    specify 'PyCall does not releases GVL during Python C API invocation' do
+      py_time = PyCall.import_module('time')
+
+      mutex = Mutex.new
+      cv = ConditionVariable.new
+      cancel = false
+      counter = Thread.start do
+        count = 0
+        mutex.synchronize do
+          until cancel
+            count += 1
+            cv.wait(mutex, 0.1)
+          end
         end
+        count
       end
-      count
-    end
 
-    py_time.sleep(1)
+      py_time.sleep(1)
 
-    mutex.synchronize do
-      cancel = true
-      cv.signal
-    end
+      mutex.synchronize do
+        cancel = true
+        cv.signal
+      end
 
-    expect(counter.value).to be >= 5
+      expect(counter.value).to be < 5
+    end
   end
 
-  it 'acquires GVL during calling Ruby from Python' do
-    gvl_checker = PyCall::GvlChecker.allocate
-    ruby_object_test = PyCall.import_module('pycall.ruby_object_test')
-    expect(ruby_object_test.call_callable(gvl_checker)).to eq(true)
+  context 'inside of .without_gvl' do
+    specify 'PyCall releases GVL during Python C API invocation' do
+      py_time = PyCall.import_module('time')
+
+      mutex = Mutex.new
+      cv = ConditionVariable.new
+      cancel = false
+      counter = Thread.start do
+        count = 0
+        mutex.synchronize do
+          until cancel
+            count += 1
+            cv.wait(mutex, 0.1)
+          end
+        end
+        count
+      end
+
+      PyCall.without_gvl do
+        py_time.sleep(1)
+      end
+
+      mutex.synchronize do
+        cancel = true
+        cv.signal
+      end
+
+      expect(counter.value).to be >= 5
+    end
+
+    specify 'PyCall acquires GVL during calling Ruby from Python' do
+      gvl_checker = PyCall::GvlChecker.allocate
+      ruby_object_test = PyCall.import_module('pycall.ruby_object_test')
+      PyCall.without_gvl do
+        expect(ruby_object_test.call_callable(gvl_checker)).to eq(true)
+      end
+    end
   end
 end