What is the proper way of initializing and finalizing the python interpreter in a C++ class in Pybind11 for multi threads?

[chenzhengda]

What is the proper way of initializing and finalizing the python interpreter in a C++ class in Pybind11 for multi threads?

#include <iostream>
#include <thread>
#include <vector>


#include <pybind11/pybind11.h>
#include <pybind11/embed.h>
#include <pybind11/stl.h>
#include <vector>
#include <string>
#include <mutex>
#include <thread>

namespace py = pybind11;

class TransformerTokenizer {
public:
    TransformerTokenizer() {
        auto transformers = py::module_::import("transformers");
        tokenizer = transformers.attr("AutoTokenizer").attr("from_pretrained")("bert-base-uncased");
        std::cout << "1" <<std::endl;
    }

    void encode(const std::string& input, std::vector<int>& ids) {
        std::lock_guard<std::mutex> guard(mutex_);
        py::list encoded_output = tokenizer.attr("encode")(input).cast<py::list>();
        ids.clear(); 
        for (auto id : encoded_output) {
            ids.push_back(id.cast<int>());
        }
        std::cout << "2" <<std::endl;
    }

    void decode(const std::vector<int>& ids, std::string& text) {
        std::lock_guard<std::mutex> guard(mutex_);
        py::object decoded_output = tokenizer.attr("decode")(ids);
        text = decoded_output.cast<std::string>();
        std::cout << "3" <<std::endl;
    }

private:
   // I think the problem should be here.
    py::scoped_interpreter guard{};
    py::object tokenizer;
    std::mutex mutex_;
};

void thread_function(TransformerTokenizer& tokenizer, const std::string& text, int thread_id) {
    {
    std::vector<int> ids;
    tokenizer.encode(text, ids);

    std::string decoded_text;
    tokenizer.decode(ids, decoded_text);

    std::cout << "Thread " << thread_id << ": " << decoded_text << std::endl;
    }
}

int main() {
    TransformerTokenizer tokenizer;

    std::string text = "Hello, world! This is a test for multi-threading.";
    const int num_threads = 4;
    std::vector<std::thread> threads;


    for (int i = 0; i < num_threads; ++i) {
        thread_function(tokenizer, text, i);
        // threads.emplace_back(thread_function, std::ref(tokenizer), text, i);
    }

    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

[chenzhengda]

terminate called after throwing an instance of 'std::runtime_error'
what(): pybind11::object_api<>::operator() PyGILState_Check() failure.

[jcelerier]

it is not possible: from the docs: https://pybind11.readthedocs.io/en/stable/advanced/embedding.html

Creating two concurrent scoped_interpreter guards is a fatal error. So is calling initialize_interpreter for a second time after the interpreter has already been initialized.