[C++-sig] Thread safety (original) (raw)

dueymk dueymk at everestkc.net
Fri Dec 16 20:36:34 CET 2005

Hi, I'm wrapping a multi-threaded C++ dll with Boost.Python. A thread is created when a wrapped structure is subclassed and instantiated in Python. This thread spends most of it's time in C++ but calls a virtual function which may be overridden by the Python subclass. I've done the following:

class Original { int counter;

virtual bool Process(int *count)
{
    *count++;
    return true;
}

}

struct PythonOriginal : Original, wrapper { bool Process(int *count) { if (override Process = this->get_override("Process")) { PyGILState_STATE gstate; gstate = PyGILState_Ensure();

        bool answer = call<bool>(Process.ptr(), boost::ref(count));

        PyGILState_Release(gstate);
        return answer;
    }
    else
        return Original::Process(count);
}

bool default_Process(int *count)
{
    return this->PleoraCamera::ProcessFrame(count);
}

}

BOOST_PYTHON_MODULE(PythonOriginal) { class_<PythonOriginal, boost::noncopyable >("Original") .def("Process", &Original::Process, &PythonOriginal::default_Process) ; }

Then in Python:

class PyOrig(Original): def Process(self, count): count = count + 10 return True

orig = PyOrig()

The only thing I did for thread safety was to add the PyGILState calls to the virtual function wrapper around the call<>. After all that, my question is, is that sufficient? Also, are there any obvious problems with this example. It seems to work fine.

Jim

More information about the Cplusplus-sig mailing list