Use multiple threading to call functions in C++ shared library

[zliucd]

Hi,

There is a class in C++ shared library, and the class' functions are called by Python using Pybind.

How to call the functions using multithreading? I tried multiple threading in Python, but it is not real multiple threading (due to GIL)

The use case is Python handles HTTP requests and then calls C++ functions. As there are concurrent requests, using multiple threading to call C++ functions is desired.

Thanks for your help.

[jagerman]

Python threads are real threads, but they are often hobbled by the GIL. Pybind, however, allows you to release the GIL in long-running C++ code that doesn't need to touch Python, which will leave that thread running the C++ code while it switches to another thread for Python execution. Have a look at https://pybind11.readthedocs.io/en/stable/advanced/misc.html#global-interpreter-lock-gil for how to interact with the GIL for allowing this.

[zliucd]

Thanks, I will give a try. It seems handling GIL is a little tricky.

[jagerman]

Thanks, I will give a try. It seems handling GIL is a little tricky.

It is, but the general rule is that once you are in C++ land and are not going to touch Python (including using any of pybind's wrapped types like py::str and whatnot), you can make function wrappers like this:

m.def("some_long_running_function", [](int x) {
    py::gil_scoped_release nogil{};
    return some_long_running_function(x);
});

which gets the function completely out of the GIL until it finishes.

There's also a shortcut for doing this via a tag you can use when wrapping the function:

m.def("some_long_running_function", &some_long_running_function, py::call_guard<py::gil_scoped_acquire>{});

that accomplishes the same thing.

The one thing that you need to be aware of, however, is that if your function wants access into Python code or Python objects (for example, by trying to call a callback, or doing anything with a py::object or similar wrapper) you need to either let the gil_scoped_release object fall out of scope or you need to take a gil_scoped_acquire, e.g.

m.def("f", [](int x, py::function g) {
    py::gil_scoped_release nogil{};
    int intermediate_value = some_cpp_func(x);
    {
        py::gil_scope_acquire gil{};
        // We now have the GIL, so it's safe to use py:: objects and call into Python code
        g(intermediate_value);
    }
    // No GIL here, again, so we aren't blocking other Python threads.
    return another_func();
});

If you don't do that, trying to touch anything that belongs to the Python interpreter without the GIL held is a recipe for quickly segfaulting.

[AlexanderSerov]

Calling python callback from C++ acquire GIL automatically
So

        py::gil_scope_acquire gil{};
        // We now have the GIL, so it's safe to use py:: objects and call into Python code
        g(intermediate_value);

py::gil_scope_acquire gil{}; is redundant here