Add RAII class to release the GIL.

insertinterestingnamehere · insertinterestingnamehere · commit 58082f72f84d · 2016-06-22T21:39:17.000-06:00
Rename the existing RAII class for acquiring the GIL to
something slightly less verbose.
diff --git a/dynd/include/callables/apply_pyobject_callable.hpp b/dynd/include/callables/apply_pyobject_callable.hpp
@@ -24,35 +24,35 @@ namespace nd {
         return dst_tp;
       }
 
-/*
-      void instantiate(dynd::nd::call_node *&node, char *DYND_UNUSED(data), dynd::nd::kernel_builder *ckb,
-                       const dynd::ndt::type &dst_tp, const char *dst_arrmeta, intptr_t nsrc,
-                       const dynd::ndt::type *src_tp, const char *const *src_arrmeta, dynd::kernel_request_t kernreq,
-                       intptr_t nkwd, const dynd::nd::array *kwds,
-                       const std::map<std::string, dynd::ndt::type> &tp_vars)
-      {
-        pydynd::PyGILState_RAII pgs;
-
-        std::vector<dynd::ndt::type> src_tp_copy(nsrc);
-        for (int i = 0; i < nsrc; ++i) {
-          src_tp_copy[i] = src_tp[i];
-        }
-
-        intptr_t ckb_offset = ckb->size();
-        ckb->emplace_back<apply_pyobject_kernel>(kernreq);
-        apply_pyobject_kernel *self = ckb->get_at<apply_pyobject_kernel>(ckb_offset);
-        self->m_proto = dynd::ndt::callable_type::make(dst_tp, src_tp_copy);
-        self->m_pyfunc = func;
-        Py_XINCREF(self->m_pyfunc);
-        self->m_dst_arrmeta = dst_arrmeta;
-        self->m_src_arrmeta.resize(nsrc);
-        copy(src_arrmeta, src_arrmeta + nsrc, self->m_src_arrmeta.begin());
-
-        dynd::ndt::type child_src_tp = dynd::ndt::make_type<pyobject_type>();
-        dynd::nd::assign->instantiate(node, nullptr, ckb, dst_tp, dst_arrmeta, 1, &child_src_tp, nullptr,
-                                      dynd::kernel_request_single, 0, nullptr, tp_vars);
-      }
-*/
+      /*
+       void instantiate(dynd::nd::call_node *&node, char *DYND_UNUSED(data), dynd::nd::kernel_builder *ckb,
+                        const dynd::ndt::type &dst_tp, const char *dst_arrmeta, intptr_t nsrc,
+                        const dynd::ndt::type *src_tp, const char *const *src_arrmeta, dynd::kernel_request_t kernreq,
+                        intptr_t nkwd, const dynd::nd::array *kwds,
+                        const std::map<std::string, dynd::ndt::type> &tp_vars)
+       {
+         pydynd::with_gil pgs;
+
+         std::vector<dynd::ndt::type> src_tp_copy(nsrc);
+         for (int i = 0; i < nsrc; ++i) {
+           src_tp_copy[i] = src_tp[i];
+         }
+
+         intptr_t ckb_offset = ckb->size();
+         ckb->emplace_back<apply_pyobject_kernel>(kernreq);
+         apply_pyobject_kernel *self = ckb->get_at<apply_pyobject_kernel>(ckb_offset);
+         self->m_proto = dynd::ndt::callable_type::make(dst_tp, src_tp_copy);
+         self->m_pyfunc = func;
+         Py_XINCREF(self->m_pyfunc);
+         self->m_dst_arrmeta = dst_arrmeta;
+         self->m_src_arrmeta.resize(nsrc);
+         copy(src_arrmeta, src_arrmeta + nsrc, self->m_src_arrmeta.begin());
+
+         dynd::ndt::type child_src_tp = dynd::ndt::make_type<pyobject_type>();
+         dynd::nd::assign->instantiate(node, nullptr, ckb, dst_tp, dst_arrmeta, 1, &child_src_tp, nullptr,
+                                       dynd::kernel_request_single, 0, nullptr, tp_vars);
+       }
+       */
     };
 
   } // namespace pydynd::nd::functional
diff --git a/dynd/include/kernels/apply_pyobject_kernel.hpp b/dynd/include/kernels/apply_pyobject_kernel.hpp
@@ -22,7 +22,7 @@ struct apply_pyobject_kernel : dynd::nd::base_strided_kernel<apply_pyobject_kern
   ~apply_pyobject_kernel()
   {
     if (m_pyfunc != NULL) {
-      pydynd::PyGILState_RAII pgs;
+      pydynd::with_gil pgs;
       Py_DECREF(m_pyfunc);
       get_child()->destroy();
     }
diff --git a/dynd/include/kernels/numpy_ufunc.hpp b/dynd/include/kernels/numpy_ufunc.hpp
@@ -16,7 +16,7 @@ namespace nd {
       {
         if (ufunc != NULL) {
           // Acquire the GIL for the python decref
-          PyGILState_RAII pgs;
+          with_gil pgs;
           Py_DECREF(ufunc);
         }
       }
@@ -26,8 +26,7 @@ namespace nd {
     struct scalar_ufunc_ck;
 
     template <>
-    struct scalar_ufunc_ck<false>
-        : dynd::nd::base_strided_kernel<scalar_ufunc_ck<false>, 1> {
+    struct scalar_ufunc_ck<false> : dynd::nd::base_strided_kernel<scalar_ufunc_ck<false>, 1> {
       typedef scalar_ufunc_ck self_type;
 
       const scalar_ufunc_data *data;
@@ -47,46 +46,34 @@ namespace nd {
         data->funcptr(args, &dimsize, strides, data->ufunc_data);
       }
 
-      void strided(char *dst, intptr_t dst_stride, char *const *src,
-                   const intptr_t *src_stride, size_t count)
+      void strided(char *dst, intptr_t dst_stride, char *const *src, const intptr_t *src_stride, size_t count)
       {
         char *args[NPY_MAXARGS];
         // Set up the args array the way the numpy ufunc wants it
         memcpy(&args[0], &src[0], data->param_count * sizeof(void *));
         args[data->param_count] = dst;
         // Call the ufunc loop with a dim size of 1
         intptr_t strides[NPY_MAXARGS];
-        memcpy(&strides[0], &src_stride[0],
-               data->param_count * sizeof(intptr_t));
+        memcpy(&strides[0], &src_stride[0], data->param_count * sizeof(intptr_t));
         strides[data->param_count] = dst_stride;
-        data->funcptr(args, reinterpret_cast<intptr_t *>(&count), strides,
-                      data->ufunc_data);
+        data->funcptr(args, reinterpret_cast<intptr_t *>(&count), strides, data->ufunc_data);
       }
 
-      static void
-      instantiate(char *static_data, char *DYND_UNUSED(data),
-                  kernel_builder *ckb, intptr_t ckb_offset,
-                  const dynd::ndt::type &dst_tp,
-                  const char *DYND_UNUSED(dst_arrmeta),
-                  intptr_t DYND_UNUSED(nsrc), const dynd::ndt::type *src_tp,
-                  const char *const *DYND_UNUSED(src_arrmeta),
-                  dynd::kernel_request_t kernreq,
-                  const dynd::eval::eval_context *DYND_UNUSED(ectx),
-                  intptr_t nkwd, const dynd::nd::array *kwds,
-                  const std::map<std::string, dynd::ndt::type> &tp_vars)
+      static void instantiate(char *static_data, char *DYND_UNUSED(data), kernel_builder *ckb, intptr_t ckb_offset,
+                              const dynd::ndt::type &dst_tp, const char *DYND_UNUSED(dst_arrmeta),
+                              intptr_t DYND_UNUSED(nsrc), const dynd::ndt::type *src_tp,
+                              const char *const *DYND_UNUSED(src_arrmeta), dynd::kernel_request_t kernreq,
+                              const dynd::eval::eval_context *DYND_UNUSED(ectx), intptr_t nkwd,
+                              const dynd::nd::array *kwds, const std::map<std::string, dynd::ndt::type> &tp_vars)
       {
         // Acquire the GIL for creating the ckernel
-        PyGILState_RAII pgs;
-        self_type::make(
-            ckb, kernreq,
-            reinterpret_cast<std::shared_ptr<scalar_ufunc_data> *>(static_data)
-                ->get());
+        with_gil pgs;
+        self_type::make(ckb, kernreq, reinterpret_cast<std::shared_ptr<scalar_ufunc_data> *>(static_data)->get());
       }
     };
 
     template <>
-    struct scalar_ufunc_ck<true>
-        : dynd::nd::base_strided_kernel<scalar_ufunc_ck<true>, 1> {
+    struct scalar_ufunc_ck<true> : dynd::nd::base_strided_kernel<scalar_ufunc_ck<true>, 1> {
       typedef scalar_ufunc_ck self_type;
 
       const scalar_ufunc_data *data;
@@ -104,47 +91,38 @@ namespace nd {
         intptr_t strides[NPY_MAXARGS];
         memset(strides, 0, (data->param_count + 1) * sizeof(void *));
         {
-          PyGILState_RAII pgs;
+          with_gil pgs;
           data->funcptr(args, &dimsize, strides, data->ufunc_data);
         }
       }
 
-      void strided(char *dst, intptr_t dst_stride, char *const *src,
-                   const intptr_t *src_stride, size_t count)
+      void strided(char *dst, intptr_t dst_stride, char *const *src, const intptr_t *src_stride, size_t count)
       {
         char *args[NPY_MAXARGS];
         // Set up the args array the way the numpy ufunc wants it
         memcpy(&args[0], &src[0], data->param_count * sizeof(void *));
         args[data->param_count] = dst;
         // Call the ufunc loop with a dim size of 1
         intptr_t strides[NPY_MAXARGS];
-        memcpy(&strides[0], &src_stride[0],
-               data->param_count * sizeof(intptr_t));
+        memcpy(&strides[0], &src_stride[0], data->param_count * sizeof(intptr_t));
         strides[data->param_count] = dst_stride;
         {
-          PyGILState_RAII pgs;
-          data->funcptr(args, reinterpret_cast<intptr_t *>(&count), strides,
-                        data->ufunc_data);
+          with_gil pgs;
+          data->funcptr(args, reinterpret_cast<intptr_t *>(&count), strides, data->ufunc_data);
         }
       }
 
-      static intptr_t
-      instantiate(char *static_data, char *DYND_UNUSED(data), void *ckb,
-                  intptr_t ckb_offset, const dynd::ndt::type &dst_tp,
-                  const char *DYND_UNUSED(dst_arrmeta),
-                  intptr_t DYND_UNUSED(nsrc), const dynd::ndt::type *src_tp,
-                  const char *const *DYND_UNUSED(src_arrmeta),
-                  dynd::kernel_request_t kernreq,
-                  const dynd::eval::eval_context *DYND_UNUSED(ectx),
-                  intptr_t nkwd, const dynd::nd::array *kwds,
-                  const std::map<std::string, dynd::ndt::type> &tp_vars)
+      static intptr_t instantiate(char *static_data, char *DYND_UNUSED(data), void *ckb, intptr_t ckb_offset,
+                                  const dynd::ndt::type &dst_tp, const char *DYND_UNUSED(dst_arrmeta),
+                                  intptr_t DYND_UNUSED(nsrc), const dynd::ndt::type *src_tp,
+                                  const char *const *DYND_UNUSED(src_arrmeta), dynd::kernel_request_t kernreq,
+                                  const dynd::eval::eval_context *DYND_UNUSED(ectx), intptr_t nkwd,
+                                  const dynd::nd::array *kwds, const std::map<std::string, dynd::ndt::type> &tp_vars)
       {
         // Acquire the GIL for creating the ckernel
-        PyGILState_RAII pgs;
-        self_type::make(
-            ckb, kernreq, ckb_offset,
-            reinterpret_cast<std::shared_ptr<scalar_ufunc_data> *>(static_data)
-                ->get());
+        with_gil pgs;
+        self_type::make(ckb, kernreq, ckb_offset,
+                        reinterpret_cast<std::shared_ptr<scalar_ufunc_data> *>(static_data)->get());
         return ckb_offset;
       }
     };
diff --git a/dynd/include/utility_functions.hpp b/dynd/include/utility_functions.hpp
@@ -386,16 +386,32 @@ inline py_ref capture_if_not_null(PyObject *o)
   // return py_ref(o, true);
 }
 
-class PyGILState_RAII {
+// RAII class to acquire GIL.
+class with_gil {
   PyGILState_STATE m_gstate;
 
-  PyGILState_RAII(const PyGILState_RAII &);
-  PyGILState_RAII &operator=(const PyGILState_RAII &);
+  with_gil(const with_gil &) = delete;
+
+  with_gil &operator=(const with_gil &) = delete;
+
+public:
+  inline with_gil() { m_gstate = PyGILState_Ensure(); }
+
+  inline ~with_gil() { PyGILState_Release(m_gstate); }
+};
+
+// RAII class to release GIL.
+class with_nogil {
+  PyThreadState *m_tstate;
+
+  with_nogil(const with_nogil &) = delete;
+
+  with_nogil &operator=(const with_nogil &) = delete;
 
 public:
-  inline PyGILState_RAII() { m_gstate = PyGILState_Ensure(); }
+  inline with_nogil() { m_tstate = PyEval_SaveThread(); }
 
-  inline ~PyGILState_RAII() { PyGILState_Release(m_gstate); }
+  inline ~with_nogil() { PyEval_RestoreThread(m_tstate); }
 };
 
 /**

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ struct apply_pyobject_kernel : dynd::nd::base_strided_kernel<apply_pyobject_kern`
`22`	`22`	`~apply_pyobject_kernel()`
`23`	`23`	`{`
`24`	`24`	`if (m_pyfunc != NULL) {`
`25`		`- pydynd::PyGILState_RAII pgs;`
	`25`	`+ pydynd::with_gil pgs;`
`26`	`26`	`Py_DECREF(m_pyfunc);`
`27`	`27`	`get_child()->destroy();`
`28`	`28`	`}`