why halide blur algorithm is slower than the blur by opencv

[halcomcn]

loop 30 times, compare infos output:

image channel: 1
Halide Elapsed time: 7274 ms
Opencv Elapsed time: 23 ms
Halide: Done

someone can help me to explain it?
I am first time to coding halide program. thanks.

I had try some schedule to speed up, but halide is slower than opencv, it is so weird.

if I want to speed up, how can I modify these codes to get good result.

int main()
{
    cv::Mat image;
    image = imread("C:\\AIOCRProjects\\Image\\1 (1).jpg", 0); // GrayImage
    std::cout << "image channel: " << image.channels() << std::endl;

    ////////////////////////////////////////////////////////////
    auto startH = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 30; i++)
    {
        // Halide-17.0.1-x86-64-windows C++ --> Win10+64bit+VS2022
        cv::Mat HalideBlur;
        HalideBlur = aiPredict.BlurHal(image);
        cv::Mat HalideThreshold;
        HalideThreshold = aiPredict.ThresholdHal(HalideBlur, 128.0f);
    }
    auto endH = std::chrono::high_resolution_clock::now();
    auto durationH = std::chrono::duration_cast<std::chrono::milliseconds>(endH - startH);
    std::cout << "Halide Elapsed time: " << durationH.count() << " ms" << std::endl;
    //
    auto startO = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 30; i++)
    {
        // opencv C++ --> Win10+64bit+VS2022
        cv::Mat opencvBlur;
        cv::blur(image, opencvBlur, cv::Size(3, 3));
        cv::Mat opencvThreshold;
        cv::threshold(opencvBlur, opencvThreshold, 128.0, 255.0, cv::THRESH_BINARY);
    }
    auto endO = std::chrono::high_resolution_clock::now();
    auto durationO = std::chrono::duration_cast<std::chrono::milliseconds>(endO - startO);
    std::cout << "Opencv Elapsed time: " << durationO.count() << " ms" << std::endl;
    ////////////////////////////////////////////////////////////
    std::cout << "Halide: " << "Done" << std::endl;

}

cv::Mat AIpredict::BlurHal(cv::Mat inputMat)
{
    Halide::Var x, y;
    Halide::Buffer<uint8_t> input = Mat2Buffer(inputMat); // GrayImage
    Halide::Func clamped("clamped");
    Expr clamped_x = clamp(x, 0, input.width() - 1);
    Expr clamped_y = clamp(y, 0, input.height() - 1);
    clamped(x, y) = input(clamped_x, clamped_y, 0);
    Func input_16("input_16");
    input_16(x, y) = cast<uint16_t>(clamped(x, y));
    Func blur_x("blur_x");
    blur_x(x, y) = (input_16(x - 1, y) + 2 * input_16(x, y) + input_16(x + 1, y)) / 4;
    Func blur_y("blur_y");
    blur_y(x, y) = (blur_x(x, y - 1) + 2 * blur_x(x, y) + blur_x(x, y + 1)) / 4;
    Func output("output");
    output(x, y) = cast<uint8_t>(blur_y(x, y));
    Buffer<uint8_t> result = output.realize({ input.width(), input.height() });  // GrayImage
    return Buffer2Mat(result);
}
cv::Mat AIpredict::ThresholdHal(cv::Mat inputMat, float thre)
{
    Halide::Var x, y;
    Halide::Buffer<uint8_t> input = Mat2Buffer(inputMat); // GrayImage
    Halide::Func output;
    output(x, y) = cast<float>(input(x, y, 0));
    output(x, y) = Halide::select(output(x, y) > thre, 255.0f, 0.0f);
    Func result;
    result(x, y) = cast<uint8_t>(output(x, y));
    Buffer<uint8_t> resultBuffer = result.realize({ input.width(), input.height() });
    return Buffer2Mat(resultBuffer);
}

[abadams]

It's slow because the way you've written the code, every time you blur it compiles the Halide code from scratch. Define the pipeline once, using ImageParams for the inputs (not Buffers), and then call realize on it multiple times, swapping out the input buffer using ImageParam::set.

Also, defining blur and threshold as two separate pipelines and then calling them one after the other defeats one of the main ways Halide beats libraries like OpenCV, which is by fusing computation down long imaging pipelines for better locality. If you want to blur then threshold, you should define a single Halide pipeline that blurs then thresholds, so that you can fuse the blur into the thresholding operation.

[halcomcn]

much faster. i should learn it step by step. anyway, thanks,