How a bind a C++ class whose memeber function invoke taskflow, a high performance and parallelism C++ library.

[HRXWEB]

hi, all, I am noob to pybind11.

extremely grateful for someone solve this problem

the brief of taskflow is here

Question

After I pybind this C++ class:

PYBIND11_MODULE(dataflow_py, m) {
    auto pipeline_module = m.def_submodule("pipeline", "Dataflow pipeline module.");
    pybind11::class_<ADCU5vFlow>(pipeline_module, "ADCU5vFlow")
        .def(pybind11::init<const std::string&, const std::string&, int, int, int, int, int, int>())
        .def("SetNumLines", &ADCU5vFlow::SetNumLines)
        .def("ProcessDataPipeline", &ADCU5vFlow::ProcessDataPipeline, pybind11::call_guard<pybind11::gil_scoped_release>());
    pipeline_module.def("dummy_func", &dummy_func);
}

when I import this package by import dataflow_py.pipeline in python shell, it will stuck.

The related definition of c++ class is following:

// adcu_5v_flow.h
class ADCU5vFlow {
public:
    ADCU5vFlow(const std::string &config_path, const std::string &path_or_device, int num_camera,
               int width, int height, int frame_rate, int dst_width, int dst_height);

    void ProcessDataPipeline();

    void SetNumLines(int num_lines) { num_lines_ = num_lines; }
private:
    // some private func
private:
    int num_lines_{2};

    YAML::Node config_node_{};
    std::vector<std::string> enabled_post_processors_name_{};

    std::unique_ptr<CameraManager> camera_manager_{};
    std::unique_ptr<dataflow::vision::ModelInfer> model_infer_{};
    std::unique_ptr<ADCU5vBusiness> adcu_5v_business_{};
    dataflow::pipeline::message_interface::MessageProcessorManager message_processor_manager_{false, true};
}

// adcu_5v_flow.cpp
ADCU5vFlow::ADCU5vFlow(const std::string &config_path, const std::string &path_or_device, int num_camera,
                       int width, int height, int frame_rate, int dst_width, int dst_height)
    : model_infer_(std::make_unique<dataflow::vision::ModelInfer>(config_path)),
      adcu_5v_business_(std::make_unique<ADCU5vBusiness>()) {
    camera_manager_ = std::make_unique<CameraManager>(path_or_device, num_camera, width, height, frame_rate, dst_width, dst_height);
    if (!model_infer_ || !adcu_5v_business_ || !camera_manager_) {
        throw std::runtime_error("Failed to initialize components");
    }

    InitConfig(config_path);
}
void ADCU5vFlow::ProcessDataPipeline() {
    // dataflow => camera -> model -> business
    tf::Taskflow taskflow("pipeline");
    tf::Executor executor;

    static auto post_process_flow = BuidPostProcessFlow();
    static auto message_processor_flow = BuildMessageProcessorFlow();
    // Create a pipeline graph
    tf::DataPipeline pl(num_lines_,
                        tf::make_data_pipe<void, cv::Mat>(tf::PipeType::SERIAL, [&](tf::Pipeflow &pf) {
                            FrameMarkStart("Inference");
                            ZoneScopedNS("Capture Image", TRACY_CALLSTACK);
                            return camera_manager_->GetImage();
                        }),

                        tf::make_data_pipe<cv::Mat, cv::Mat>(tf::PipeType::SERIAL, [&](cv::Mat &input) {
                            ZoneScopedNS("Pre Process", TRACY_CALLSTACK);
                            model_infer_->PreProcess(input);
                            return input;
                        }),

                        tf::make_data_pipe<cv::Mat, cv::Mat>(tf::PipeType::SERIAL, [&](cv::Mat &input) {
                            ZoneScopedNS("Model Inference", TRACY_CALLSTACK);
                            model_infer_->Inference();
                            return input;
                        }),

                        tf::make_data_pipe<cv::Mat, cv::Mat>(tf::PipeType::SERIAL, [&](cv::Mat &input) {
                            ZoneScopedNS("Post Process", TRACY_CALLSTACK);
                            executor.corun(post_process_flow);
                            return input;
                        }),
                        tf::make_data_pipe<cv::Mat, void>(tf::PipeType::SERIAL, [&](cv::Mat &input, tf::Pipeflow &pf) {
                            ZoneScopedNS("Business flow", TRACY_CALLSTACK);
                            message_processor_manager_.ProcessMessage(input, "image");
                            executor.corun(message_processor_flow);
                            FrameMarkEnd("Inference");
                        }));
    taskflow.composed_of(pl).name("pipeline");
    taskflow.dump(std::cout);

    executor.run_n(taskflow, 200).wait();
}

Guess

Maybe the python GIL causes this problem, but I have no idea to solve this.

thanks advance.

[HRXWEB]

I just to want achieve:

from dataflow_py import ADCU5vFlow
adcu_5v_flow = ADCU5vFlow(args.config, args.input, args.num_camera, width, height, args.frame_rate, dst_width, dst_height)
adcu_5v_flow.SetNumLines(args.num_lines)
adcu_5v_flow.ProcessDataPipeline()

so just binding the constructor and two public member functions.