pycall 1.0.3 → 1.3.1

data/examples/classifier_comparison.rb

@@ -2,7 +2,7 @@ require 'pycall/import'
 include PyCall::Import
 
 pyimport 'numpy', as: :np
-pyfrom 'sklearn.cross_validation', import: :train_test_split
+pyfrom 'sklearn.model_selection', import: :train_test_split
 pyfrom 'sklearn.preprocessing', import: :StandardScaler
 pyfrom 'sklearn.datasets', import: %i(make_moons make_circles make_classification)
 pyfrom 'sklearn.neighbors', import: :KNeighborsClassifier

data/examples/hist.rb

@@ -20,7 +20,7 @@ num_bins = 50
 
 fig, ax = *plt.subplots
 
-n, bins, patches = *ax.hist(x, num_bins, normed: 1)
+n, bins, patches = *ax.hist(x, num_bins, density: 1)
 
 y = mlab.normpdf(bins, mu, sigma)
 ax.plot(bins, y, '--')

data/examples/notebooks/classifier_comparison.ipynb

@@ -38,7 +38,7 @@
     "include PyCall::Import\n",
     "\n",
     "pyimport 'numpy', as: :np\n",
-    "pyfrom 'sklearn.cross_validation', import: :train_test_split\n",
+    "pyfrom 'sklearn.model_selection', import: :train_test_split\n",
     "pyfrom 'sklearn.preprocessing', import: :StandardScaler\n",
     "pyfrom 'sklearn.datasets', import: %i(make_moons make_circles make_classification)\n",
     "pyfrom 'sklearn.neighbors', import: :KNeighborsClassifier\n",

data/ext/pycall/libpython.c

@@ -30,7 +30,13 @@ lookup_libpython_api(VALUE libpython_handle, char const *name)
   arg.libpython_handle = libpython_handle;
   arg.name = name;
   addr = rb_protect((VALUE (*)(VALUE))lookup_libpython_api_0, (VALUE)&arg, &state);
-  return (state || NIL_P(addr)) ? NULL : NUM2PTR(addr);
+  if (state) {
+    rb_set_errinfo(Qnil);
+    return NULL;
+  }
+  else {
+    return NIL_P(addr) ? NULL : NUM2PTR(addr);
+  }
 }
 
 #define LOOKUP_API_ENTRY(api_name) lookup_libpython_api(libpython_handle, #api_name)
@@ -94,6 +100,7 @@ pycall_init_libpython_api_table(VALUE libpython_handle)
   INIT_API_TABLE_ENTRY(_PyObject_New, required);
   INIT_API_TABLE_ENTRY(PyCallable_Check, required);
   INIT_API_TABLE_ENTRY(PyObject_IsInstance, required);
+  INIT_API_TABLE_ENTRY(PyObject_IsSubclass, required);
   INIT_API_TABLE_ENTRY2(PyObject_Hash._hash_t, PyObject_Hash, required);
   INIT_API_TABLE_ENTRY(PyObject_RichCompare, required);
   INIT_API_TABLE_ENTRY(PyObject_Call, required);
@@ -154,12 +161,16 @@ pycall_init_libpython_api_table(VALUE libpython_handle)
 
   INIT_API_TABLE_ENTRY(PyIter_Next, required);
 
+  INIT_API_TABLE_ENTRY(PyEval_ThreadsInitialized, required);
+  INIT_API_TABLE_ENTRY(PyEval_InitThreads, required);
+
   INIT_API_TABLE_ENTRY(PyErr_Occurred, required);
   INIT_API_TABLE_ENTRY(PyErr_Fetch, required);
   INIT_API_TABLE_ENTRY(PyErr_Restore, required);
   INIT_API_TABLE_ENTRY(PyErr_Clear, required);
   INIT_API_TABLE_ENTRY(PyErr_SetString, required);
   INIT_API_TABLE_ENTRY(PyErr_Format, required);
+  INIT_API_TABLE_ENTRY(PyErr_SetInterrupt, required);
 
   INIT_API_TABLE_ENTRY(PyImport_ImportModule, required);
   INIT_API_TABLE_ENTRY(PyImport_ImportModuleLevel, required);

data/ext/pycall/pycall.c

@@ -1,4 +1,5 @@
 #include "pycall_internal.h"
+#include "pycall.h"
 #include <ruby/encoding.h>
 
 #include <stdarg.h>
@@ -69,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 = {
@@ -143,6 +190,12 @@ get_pyobj_ptr(VALUE obj)
   return pyobj;
 }
 
+PyObject *
+pycall_pyptr_get_pyobj_ptr(VALUE pyptr)
+{
+  return get_pyobj_ptr(pyptr);
+}
+
 static inline PyObject*
 try_get_pyobj_ptr(VALUE obj)
 {
@@ -445,7 +498,7 @@ get_pytypeobj_ptr(VALUE obj)
 static inline PyTypeObject*
 try_get_pytypeobj_ptr(VALUE obj)
 {
-  if (is_pycall_pytypeptr(obj)) return NULL;
+  if (!is_pycall_pytypeptr(obj)) return NULL;
   return (PyTypeObject*)DATA_PTR(obj);
 }
 
@@ -534,6 +587,20 @@ pycall_pytypeptr_eqq(VALUE obj, VALUE other)
   return Qfalse;
 }
 
+static VALUE
+pycall_pytypeptr_subclass_p(VALUE obj, VALUE other)
+{
+  PyTypeObject* pytype = get_pytypeobj_ptr(obj);
+  if (is_pycall_pyptr(other)) {
+    PyTypeObject* pytype_other = try_get_pytypeobj_ptr(other);
+    if (pytype_other) {
+      int res =  Py_API(PyObject_IsSubclass)((PyObject *)pytype, (PyObject *)pytype_other);
+      return res ? Qtrue : Qfalse;
+    }
+  }
+  return Qfalse;
+}
+
 /* ==== PyCall::LibPython::API ==== */
 
 static VALUE
@@ -727,7 +794,6 @@ pycall_libpython_helpers_m_compare(VALUE mod, VALUE op, VALUE pyptr_a, VALUE pyp
 }
 
 static int is_pyobject_wrapper(VALUE obj);
-static PyObject * pycall_pyobject_wrapper_get_pyobj_ptr(VALUE obj);
 
 VALUE
 pycall_getattr_default(VALUE obj, char const *name, VALUE default_value)
@@ -858,6 +924,47 @@ pycall_extract_kwargs_from_ruby_hash(VALUE key, VALUE value, VALUE arg)
   return ST_CONTINUE;
 }
 
+static void
+pycall_interrupt_python_thread(void *ptr)
+{
+  Py_API(PyErr_SetInterrupt)();
+}
+
+struct call_pyobject_call_params {
+  PyObject *pycallable;
+  PyObject *args;
+  PyObject *kwargs;
+};
+
+static inline PyObject *
+call_pyobject_call(struct call_pyobject_call_params *params)
+{
+  PyObject *res;
+  res = Py_API(PyObject_Call)(params->pycallable, params->args, params->kwargs); /* New reference */
+  return res;
+}
+
+PyObject *
+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;
+
+  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;
+}
+
 static VALUE
 pycall_call_python_callable(PyObject *pycallable, int argc, VALUE *argv)
 {
@@ -905,7 +1012,7 @@ pycall_call_python_callable(PyObject *pycallable, int argc, VALUE *argv)
     }
   }
 
-  res = Py_API(PyObject_Call)(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");
   }
@@ -1213,7 +1320,7 @@ pycall_pyobject_wrapper_get_pyptr(VALUE obj)
   return rb_funcall(obj, rb_intern("__pyptr__"), 0);
 }
 
-static PyObject *
+PyObject *
 pycall_pyobject_wrapper_get_pyobj_ptr(VALUE obj)
 {
   VALUE pyptr = pycall_pyobject_wrapper_get_pyptr(obj);
@@ -1235,11 +1342,39 @@ pycall_pyobject_wrapper_check_get_pyobj_ptr(VALUE obj, PyTypeObject *pytypeobj)
 
 /* ==== PyCall::Conversion ==== */
 
+static int
+get_mapped_ancestor_class_iter(VALUE key, VALUE value, VALUE arg)
+{
+  VALUE *args = (VALUE *)arg;
+  if (RTEST(pycall_pytypeptr_subclass_p(args[0], key))) {
+    args[1] = value;
+    return ST_STOP;
+  }
+  return ST_CONTINUE;
+}
+
+static VALUE
+pycall_python_type_mapping_get_mapped_ancestor_class(VALUE pytypeptr)
+{
+  VALUE args[2];
+  args[0] = pytypeptr;
+  args[1] = Qnil;
+
+  rb_hash_foreach(python_type_mapping, get_mapped_ancestor_class_iter, (VALUE)args);
+
+  return args[1];
+}
+
 static VALUE
 pycall_python_type_mapping_get_mapped_class(VALUE pytypeptr)
 {
+  VALUE mapped;
   (void)check_get_pytypeobj_ptr(pytypeptr);
-  return rb_hash_lookup(python_type_mapping, pytypeptr);
+  mapped = rb_hash_lookup(python_type_mapping, pytypeptr);
+  if (NIL_P(mapped)) {
+    mapped = pycall_python_type_mapping_get_mapped_ancestor_class(pytypeptr);
+  }
+  return mapped;
 }
 
 static int
@@ -1947,6 +2082,10 @@ init_python(void)
   Py_API(Py_InitializeEx)(0);
   Py_API(PySys_SetArgvEx)(0, (char **)argv, 0);
 
+  if (!Py_API(PyEval_ThreadsInitialized)()) {
+    Py_API(PyEval_InitThreads)();
+  }
+
   /* check the availability of stackless extension */
   python_has_stackless_extension = (Py_API(PyImport_ImportModule)("stackless") != NULL);
   if (!python_has_stackless_extension) {
@@ -2078,6 +2217,7 @@ init_tuple(void)
   rb_define_singleton_method(cTuple, "new", pycall_tuple_s_new, -1);
   rb_define_method(cTuple, "length", pycall_tuple_length, 0);
   rb_define_method(cTuple, "to_a", pycall_tuple_to_a, 0);
+  rb_define_alias(cTuple, "to_ary", "to_a");
 }
 
 void
@@ -2096,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);
@@ -2132,6 +2275,7 @@ Init_pycall(void)
   rb_define_method(cPyTypePtr, "__tp_basicsize__", pycall_pytypeptr_get_tp_basicsize, 0);
   rb_define_method(cPyTypePtr, "__tp_flags__", pycall_pytypeptr_get_tp_flags, 0);
   rb_define_method(cPyTypePtr, "===", pycall_pytypeptr_eqq, 1);
+  rb_define_method(cPyTypePtr, "<", pycall_pytypeptr_subclass_p, 1);
 
   /* PyCall::LibPython::API */
 

data/ext/pycall/pycall.h

@@ -0,0 +1,23 @@
+#ifndef PYCALL_H
+#define PYCALL_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+VALUE pycall_pyptr_new(PyObject *pyobj);
+PyObject *pycall_pyptr_get_pyobj_ptr(VALUE pyptr);
+VALUE pycall_pyobject_to_ruby(PyObject *pyobj);
+PyObject *pycall_pyobject_wrapper_get_pyobj_ptr(VALUE obj);
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+} /* extern "C" { */
+#endif
+
+#endif /* PYCALL_H */

data/ext/pycall/pycall_internal.h

@@ -10,10 +10,20 @@ 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)))
@@ -34,6 +44,9 @@ pycall_integer_type_p(VALUE obj)
 #endif
 
 void ruby_debug_breakpoint();
+int ruby_thread_has_gvl_p(void);
+
+#define CALL_WITH_GVL(func, data) rb_thread_call_with_gvl((void * (*)(void *))(func), (void *)(data))
 
 /* ==== python ==== */
 
@@ -488,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 {
@@ -525,6 +555,7 @@ typedef struct {
   PyObject * (* _PyObject_New)(PyTypeObject *);
   int (* PyCallable_Check)(PyObject *);
   int (* PyObject_IsInstance)(PyObject *, PyObject *);
+  int (* PyObject_IsSubclass)(PyObject *, PyObject *);
   union {
     long      (* _long)(PyObject *);
     Py_hash_t (* _hash_t)(PyObject *);
@@ -581,12 +612,16 @@ typedef struct {
 
   PyObject * (* PyIter_Next)(PyObject *);
 
+  int (* PyEval_ThreadsInitialized)(void);
+  void (* PyEval_InitThreads)(void);
+
   PyObject * (* PyErr_Occurred)(void);
   void (* PyErr_Fetch)(PyObject **, PyObject **, PyObject **);
   void (* PyErr_Restore)(PyObject *, PyObject *, PyObject *);
   void (* PyErr_Clear)(void);
   void (* PyErr_SetString)(PyObject *, const char *);   /* decoded from utf-8 */
   void (* PyErr_Format)(PyObject *, const char *, ...); /* ASCII-encoded string  */
+  void (* PyErr_SetInterrupt)(void);
 
   PyObject * (* PyImport_ImportModule)(char const*);
   PyObject * (* PyImport_ImportModuleLevel)(char const*, PyObject *, PyObject *, PyObject *, int);
@@ -637,7 +672,6 @@ VALUE pycall_import_module_level(char const *name, VALUE globals, VALUE locals,
 VALUE pycall_getattr_default(VALUE pyobj, char const *name, VALUE default_value);
 VALUE pycall_getattr(VALUE pyobj, char const *name);
 
-VALUE pycall_pyobject_to_ruby(PyObject *);
 VALUE pycall_pytype_to_ruby(PyObject *);
 VALUE pycall_pymodule_to_ruby(PyObject *);
 VALUE pycall_pybool_to_ruby(PyObject *);

data/ext/pycall/ruby_wrapper.c

@@ -1,33 +1,35 @@
 #include "pycall_internal.h"
+#include "pycall.h"
 
 static PyMemberDef PyRuby_members[] = {
   {"ruby_object_ptr", Py_T_PYSSIZET, offsetof(PyRubyObject, ruby_object), Py_READONLY},
   {NULL} /* sentinel */
 };
 
-static void PyRuby_dealloc(PyRubyObject *);
-static PyObject * PyRuby_repr(PyRubyObject *);
-static PyObject * PyRuby_call(PyRubyObject *, PyObject *, PyObject *);
-static PyObject * PyRuby_getattro(PyRubyObject *, PyObject *);
+static VALUE PyRuby_get_ruby_object_and_set_pyerr(PyObject *pyobj);
+static void PyRuby_dealloc_with_gvl(PyRubyObject *);
+static PyObject * PyRuby_repr_with_gvl(PyRubyObject *);
+static PyObject * PyRuby_call_with_gvl(PyRubyObject *, PyObject *, PyObject *);
+static PyObject * PyRuby_getattro_with_gvl(PyRubyObject *, PyObject *);
 
 PyTypeObject PyRuby_Type = {
   PyVarObject_HEAD_INIT(NULL, 0)
   "PyCall.ruby_object", /* tp_name */
   sizeof(PyRubyObject), /* tp_basicsize */
   0, /* tp_itemsize */
-  (destructor)PyRuby_dealloc,    /* tp_dealloc */
+  (destructor)PyRuby_dealloc_with_gvl, /* tp_dealloc */
   0,                             /* tp_print */
   0,                             /* tp_getattr */
   0,                             /* tp_setattr */
   0,                             /* tp_reserved */
-  (reprfunc)PyRuby_repr,         /* tp_repr */
+  (reprfunc)PyRuby_repr_with_gvl, /* tp_repr */
   0,                             /* tp_as_number */
   0,                             /* tp_as_sequence */
   0,                             /* tp_as_mapping */
   {0},                           /* tp_hash  */
-  (ternaryfunc)PyRuby_call,      /* tp_call */
+  (ternaryfunc)PyRuby_call_with_gvl, /* tp_call */
   0,                             /* tp_str */
-  (getattrofunc)PyRuby_getattro, /* tp_getattro */
+  (getattrofunc)PyRuby_getattro_with_gvl, /* tp_getattro */
   0,                             /* tp_setattro */
   0,                             /* tp_as_buffer */
   Py_TPFLAGS_BASETYPE,           /* tp_flags */
@@ -42,8 +44,8 @@ PyTypeObject PyRuby_Type = {
   PyRuby_members,                /*tp_members*/
 };
 
-PyObject *
-PyRuby_New(VALUE ruby_object)
+static PyObject *
+PyRuby_New_impl(VALUE ruby_object)
 {
   PyRubyObject *op;
 
@@ -53,59 +55,17 @@ PyRuby_New(VALUE ruby_object)
   return (PyObject *)op;
 }
 
-static VALUE
-funcall_id2ref(VALUE object_id)
-{
-  VALUE rb_mObjSpace;
-  object_id = rb_check_to_integer(object_id, "to_int");
-  rb_mObjSpace = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
-  return rb_funcall(rb_mObjSpace, rb_intern("_id2ref"), 1, object_id);
-}
-
-static VALUE
-protect_id2ref(VALUE object_id)
-{
-  VALUE obj;
-  int state;
-
-  obj = rb_protect((VALUE (*)(VALUE))funcall_id2ref, object_id, &state);
-  if (state)
-    return Qundef;
-
-  return obj;
-}
-
-static VALUE
-protect_id2ref_and_set_pyerr(VALUE object_id)
+PyObject *
+PyRuby_New(VALUE ruby_object)
 {
-  VALUE obj = protect_id2ref(object_id);
-  if (obj != Qundef)
-    return obj;
-
-  obj = rb_errinfo();
-  if (RTEST(rb_obj_is_kind_of(obj, rb_eRangeError))) {
-    Py_API(PyErr_SetString)(Py_API(PyExc_RuntimeError), "[BUG] referenced object was garbage-collected");
+  if (!ruby_thread_has_gvl_p()) {
+    CALL_WITH_GVL(PyRuby_New_impl, ruby_object);
   }
-  else {
-    VALUE emesg = rb_check_funcall(obj, rb_intern("message"), 0, 0);
-    Py_API(PyErr_Format)(Py_API(PyExc_RuntimeError),
-        "[BUG] Unable to obtain ruby object from ID: %s (%s)",
-        StringValueCStr(emesg), rb_class2name(CLASS_OF(obj)));
-  }
-  return Qundef;
-}
 
-static VALUE
-PyRuby_get_ruby_object_and_set_pyerr(PyObject *pyobj)
-{
-  VALUE obj_id;
-  if (!PyRuby_Check(pyobj))
-    return Qundef;
-  obj_id = rb_obj_id(PyRuby_get_ruby_object(pyobj));
-  return protect_id2ref_and_set_pyerr(obj_id);
+  return PyRuby_New_impl(ruby_object);
 }
 
-static void
+static void *
 PyRuby_dealloc(PyRubyObject *pyro)
 {
   VALUE obj;
@@ -117,9 +77,20 @@ PyRuby_dealloc(PyRubyObject *pyro)
 #endif /* PYCALL_DEBUG_DUMP_REFCNT */
 
   if (obj == Qundef)
-    return;
+    return NULL;
 
   pycall_gcguard_unregister_pyrubyobj((PyObject *)pyro);
+
+  return NULL;
+}
+
+static void
+PyRuby_dealloc_with_gvl(PyRubyObject *pyro)
+{
+  if (!ruby_thread_has_gvl_p()) {
+    CALL_WITH_GVL(PyRuby_dealloc, pyro);
+  }
+  PyRuby_dealloc(pyro);
 }
 
 static PyObject *
@@ -137,6 +108,15 @@ PyRuby_repr(PyRubyObject *pyro)
   return res;
 }
 
+static PyObject *
+PyRuby_repr_with_gvl(PyRubyObject *pyro)
+{
+  if (!ruby_thread_has_gvl_p()) {
+    return CALL_WITH_GVL(PyRuby_repr, pyro);
+  }
+  return PyRuby_repr(pyro);
+}
+
 #if SIZEOF_SSIZE_T < 8
 /* int64to32hash from src/support/hashing.c in Julia */
 static inline uint32_t
@@ -152,7 +132,7 @@ int64to32hash(uint64_t key)
 }
 #endif
 
-static long
+static void *
 PyRuby_hash_long(PyRubyObject *pyro)
 {
   VALUE obj, rbhash;
@@ -160,15 +140,24 @@ PyRuby_hash_long(PyRubyObject *pyro)
 
   obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)pyro);
   if (obj == Qundef)
-    return -1;
+    return (void *)-1;
 
   rbhash = rb_hash(obj);
   h = FIX2LONG(rbhash); /* Ruby's hash value is a Fixnum */
 
-  return h == -1 ? pycall_hash_salt : h;
+  return (void *)(h == -1 ? pycall_hash_salt : h);
 }
 
-static Py_hash_t
+static long
+PyRuby_hash_long_with_gvl(PyRubyObject *pyro)
+{
+  if (!ruby_thread_has_gvl_p()) {
+    return (long)CALL_WITH_GVL(PyRuby_hash_long, pyro);
+  }
+  return (long)PyRuby_hash_long(pyro);
+}
+
+static void *
 PyRuby_hash_hash_t(PyRubyObject *pyro)
 {
   VALUE obj, rbhash;
@@ -176,20 +165,29 @@ PyRuby_hash_hash_t(PyRubyObject *pyro)
 
   obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)pyro);
   if (obj == Qundef)
-    return -1;
+    return (void *)-1;
 
   rbhash = rb_hash(obj);
 #if SIZEOF_PY_HASH_T == SIZEOF_LONG
   /* In this case, we can assume sizeof(Py_hash_t) == sizeof(long) */
   h = NUM2SSIZET(rbhash);
-  return h == -1 ? (Py_hash_t)pycall_hash_salt : h;
+  return (void *)(h == -1 ? (Py_hash_t)pycall_hash_salt : h);
 #else
   /* In this case, we can assume sizeof(long) == 4 and sizeof(Py_hash_t) == 8 */
   h = (pycall_hash_salt_32 << 32) | FIX2LONG(rbhash);
-  return h == -1 ? ((pycall_hash_salt << 32) | pycall_hash_salt) : h;
+  return (void *)(h == -1 ? ((pycall_hash_salt << 32) | pycall_hash_salt) : h);
 #endif
 }
 
+static Py_hash_t
+PyRuby_hash_hash_t_with_gvl(PyRubyObject *pyro)
+{
+  if (!ruby_thread_has_gvl_p()) {
+    return (Py_hash_t)CALL_WITH_GVL(PyRuby_hash_hash_t, pyro);
+  }
+  return (Py_hash_t)PyRuby_hash_hash_t(pyro);
+}
+
 struct call_rb_funcallv_params {
   VALUE recv;
   ID meth;
@@ -221,15 +219,21 @@ rb_protect_funcallv(VALUE recv, ID meth, int argc, VALUE *argv, int *pstate)
   return res;
 }
 
+struct PyRuby_call_params {
+  PyRubyObject *pyro;
+  PyObject *pyobj_args;
+  PyObject *pyobj_kwargs;
+};
+
 static PyObject *
-PyRuby_call(PyRubyObject *pyro, PyObject *pyobj_args, PyObject *pyobj_kwargs)
+PyRuby_call(struct PyRuby_call_params *params)
 {
   ID id_call;
   VALUE obj, args, kwargs, res;
   PyObject *pyobj_res;
   int state;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)pyro);
+  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)params->pyro);
   if (obj == Qundef)
     return NULL;
 
@@ -239,9 +243,9 @@ PyRuby_call(PyRubyObject *pyro, PyObject *pyobj_args, PyObject *pyobj_kwargs)
     return NULL;
   }
 
-  args = pycall_pyobject_to_a(pyobj_args);
-  if (pyobj_kwargs) {
-    kwargs = pycall_pyobject_to_ruby(pyobj_kwargs);
+  args = pycall_pyobject_to_a(params->pyobj_args);
+  if (params->pyobj_kwargs) {
+    kwargs = pycall_pyobject_to_ruby(params->pyobj_kwargs);
     rb_ary_push(args, kwargs);
   }
 
@@ -255,18 +259,38 @@ PyRuby_call(PyRubyObject *pyro, PyObject *pyobj_args, PyObject *pyobj_kwargs)
 }
 
 static PyObject *
-PyRuby_getattro(PyRubyObject *pyro, PyObject *pyobj_name)
+PyRuby_call_with_gvl(PyRubyObject *pyro, PyObject *pyobj_args, PyObject *pyobj_kwargs)
+{
+  struct PyRuby_call_params params;
+  params.pyro = pyro;
+  params.pyobj_args = pyobj_args;
+  params.pyobj_kwargs = pyobj_kwargs;
+
+  if (!ruby_thread_has_gvl_p()) {
+    return CALL_WITH_GVL(PyRuby_call, &params);
+  }
+
+  return PyRuby_call(&params);
+}
+
+struct PyRuby_getattro_params {
+  PyRubyObject *pyro;
+  PyObject *pyobj_name;
+};
+
+static PyObject *
+PyRuby_getattro(struct PyRuby_getattro_params *params)
 {
   VALUE obj, name, res;
   char const *name_cstr;
   ID name_id;
   PyObject *pyobj_res;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)pyro);
+  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)params->pyro);
   if (obj == Qundef)
     return NULL;
 
-  name = pycall_pyobject_to_ruby(pyobj_name);
+  name = pycall_pyobject_to_ruby(params->pyobj_name);
   name_cstr = StringValueCStr(name);
   name_id = rb_intern(name_cstr);
 
@@ -299,21 +323,35 @@ PyRuby_getattro(PyRubyObject *pyro, PyObject *pyobj_name)
   else if (name_cstr[0] == '_' && name_cstr[1] == '_') {
     /* name.start_with? "__" */
     /* TODO: handle `__code__` and `func_code` */
-    return Py_API(PyObject_GenericGetAttr)((PyObject *)pyro, pyobj_name);
+    return Py_API(PyObject_GenericGetAttr)((PyObject *)params->pyro, params->pyobj_name);
   }
   else {
     /* TODO: handle `__code__` and `func_code` */
     if (rb_respond_to(obj, name_id)) {
       VALUE method = rb_obj_method(obj, name);
-      return PyRuby_New(method);
+      return PyRuby_New_impl(method);
     }
-    return Py_API(PyObject_GenericGetAttr)((PyObject *)pyro, pyobj_name);
+    return Py_API(PyObject_GenericGetAttr)((PyObject *)params->pyro, params->pyobj_name);
   }
 
   pyobj_res = pycall_pyobject_from_ruby(res);
   return pyobj_res;
 }
 
+static PyObject *
+PyRuby_getattro_with_gvl(PyRubyObject *pyro, PyObject *pyobj_name)
+{
+  struct PyRuby_getattro_params params;
+  params.pyro = pyro;
+  params.pyobj_name = pyobj_name;
+
+  if (!ruby_thread_has_gvl_p()) {
+    return CALL_WITH_GVL(PyRuby_getattro, &params);
+  }
+
+  return PyRuby_getattro(&params);
+}
+
 /* ==== PyCall::PyRubyPtr ==== */
 
 VALUE cPyRubyPtr;
@@ -411,9 +449,9 @@ pycall_init_ruby_wrapper(void)
   PyRuby_Type.tp_flags |= pycall_default_tp_flags();
   PyRuby_Type.tp_new = Py_API(PyType_GenericNew);
   if (pycall_python_long_hash)
-    PyRuby_Type.tp_hash._long = (hashfunc_long)PyRuby_hash_long;
+    PyRuby_Type.tp_hash._long = (hashfunc_long)PyRuby_hash_long_with_gvl;
   else
-    PyRuby_Type.tp_hash._hash_t = (hashfunc_hash_t)PyRuby_hash_hash_t;
+    PyRuby_Type.tp_hash._hash_t = (hashfunc_hash_t)PyRuby_hash_hash_t_with_gvl;
 
   if (Py_API(PyType_Ready)(&PyRuby_Type) < 0) {
     pycall_pyerror_fetch_and_raise("PyType_Ready in pycall_init_ruby_wrapper");
@@ -430,3 +468,57 @@ pycall_init_ruby_wrapper(void)
 
   rb_define_module_function(mPyCall, "wrap_ruby_object", pycall_m_wrap_ruby_object, 1);
 }
+
+/* --- File internal utilities --- */
+
+static VALUE
+funcall_id2ref(VALUE object_id)
+{
+  VALUE rb_mObjSpace;
+  object_id = rb_check_to_integer(object_id, "to_int");
+  rb_mObjSpace = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
+  return rb_funcall(rb_mObjSpace, rb_intern("_id2ref"), 1, object_id);
+}
+
+static VALUE
+protect_id2ref(VALUE object_id)
+{
+  VALUE obj;
+  int state;
+
+  obj = rb_protect((VALUE (*)(VALUE))funcall_id2ref, object_id, &state);
+  if (state)
+    return Qundef;
+
+  return obj;
+}
+
+static VALUE
+protect_id2ref_and_set_pyerr(VALUE object_id)
+{
+  VALUE obj = protect_id2ref(object_id);
+  if (obj != Qundef)
+    return obj;
+
+  obj = rb_errinfo();
+  if (RTEST(rb_obj_is_kind_of(obj, rb_eRangeError))) {
+    Py_API(PyErr_SetString)(Py_API(PyExc_RuntimeError), "[BUG] referenced object was garbage-collected");
+  }
+  else {
+    VALUE emesg = rb_check_funcall(obj, rb_intern("message"), 0, 0);
+    Py_API(PyErr_Format)(Py_API(PyExc_RuntimeError),
+        "[BUG] Unable to obtain ruby object from ID: %s (%s)",
+        StringValueCStr(emesg), rb_class2name(CLASS_OF(obj)));
+  }
+  return Qundef;
+}
+
+static VALUE
+PyRuby_get_ruby_object_and_set_pyerr(PyObject *pyobj)
+{
+  VALUE obj_id;
+  if (!PyRuby_Check(pyobj))
+    return Qundef;
+  obj_id = rb_obj_id(PyRuby_get_ruby_object(pyobj));
+  return protect_id2ref_and_set_pyerr(obj_id);
+}