Halide slower than OpenCV GaussianBlur?

[arturoar3nas]

I perform a benchmarking using OpenCV and Halide for measure GaussianBlur filter and i get the following results :

-------------------------------------------------------------------------------
GaussianBlur_Halide
-------------------------------------------------------------------------------
benchmark name                            samples    iterations          mean
-------------------------------------------------------------------------------
GaussianBlur 1x1                               100             1     146.25 ms 
GaussianBlur 3x3                               100             1     148.32 ms 
GaussianBlur 5x5                               100             1    146.447 ms 
GaussianBlur 7x7                               100             1    150.519 ms 

-------------------------------------------------------------------------------
GaussianBlur_OpenCV
-------------------------------------------------------------------------------
benchmark name                            samples    iterations          mean
-------------------------------------------------------------------------------
GaussianBlur 1x1                              1000             2     17.138 us 
GaussianBlur 3x3                              1000             1     78.595 us 
GaussianBlur 5x5                              1000             1    126.954 us 
GaussianBlur 7x7                              1000             1    189.988 us 
GaussianBlur 9x9                          1000                 1    243.754 us 

The code for perform the Gaussian Blur is the next:

void GaussianBlur(Buffer<uint8_t> input, Buffer<uint8_t>& out, int size, float sigma)
  {
    Var x("x"), y("y"), c("c");

    int n = size;
    Func input_16("input_16");
    input_16(x, y, c) = cast<uint16_t>(input(x, y, c));
    Func kernel;
    kernel(x) = exp(-x*x/(2*sigma*sigma)) / (sqrtf(2*M_PI)*sigma);

    // Blur it horizontally:
    Func blur_x("blur_x");
    blur_x(x, y, c) = (kernel(0) * input_16(x-n, y, c) +
                               kernel(1) * input_16(x, y, c) +
                               kernel(2) * input_16(x+n, y, c)) / 4;
    // Blur it vertically:
    Func blur_y("blur_y");
    blur_y(x, y, c) = (kernel(0) * blur_x(x, y-n, c) +
                              kernel(1) * blur_x(x, y, c) +
                              kernel(2) * blur_x(x, y+n, c)) / 4;

     // Schedule it.
     blur_x.compute_root().vectorize(x, 8).parallel(y);
     blur_y.compute_at(blur_x, y).vectorize(x, 8);


    Func output("output");
    output(x, y, c) = cast<uint8_t>(blur_x(x, y, c));

    out = Halide::Buffer<uint8_t>(input.width()-n*2, input.height()-n*2, 3);
    out.set_min(n, n);
    output.realize(out);
  }

I'm developing in the following environment:

Architecture:        x86_64
CPU op-mode(s):      32-bit, 64-bit
Byte Order:          Little Endian
Address sizes:       43 bits physical, 48 bits virtual
CPU(s):              12
On-line CPU(s) list: 0-11
Thread(s) per core:  2
Core(s) per socket:  6
Socket(s):           1
NUMA node(s):        1
Vendor ID:           AuthenticAMD
CPU family:          23
Model:               8
Model name:          AMD Ryzen 5 2600X Six-Core Processor

Fedora release 30 (Thirty)
gcc version 9.2.1 20190827 (Red Hat 9.2.1-1) (GCC)

Also i am working with the next jpg image https://github.com/opencv/opencv/blob/master/samples/data/lena.jpg

This is an issue, platform error, bad implementation or merely benchmarking error?

thanks in advance!

[ashishUthama]

A thought: for smaller kernels (~<5x5) sometimes I have noticed that the naive 2D iteration to be faster than decomposing the computation.

A quick skim of the OpenCV code base shows that they do have 3x3 and 5x5 specializations.

[abadams]

I think you're doing a fresh compilation every time you call GaussianBlur, so what you're measuring is Halide compile time. The code that defines the pipeline should be separate to the code that actually blurs an image, so that you can define and compile the pipeline once, and use it to blur many images without recompiling.

[arturoar3nas]

I moved out the code that define the pipeline from the benchmark and the result change a lot!

TEST_CASE("GaussianBlur_Halide_1x1") {

  Halide::Buffer<uint8_t> input = Halide::Tools::load_image(testPath+"lena.png");
  Halide::Buffer<uint8_t> out;

  Var x("x"), y("y"), c("c");

  int n = 1;
  Func input_16("input_16");
  input_16(x, y, c) = cast<uint16_t>(input(x, y, c));
  float sigma = 1.5;
  Func kernel;
  kernel(x) = exp(-x*x/(2*sigma*sigma)) / (sqrtf(2*M_PI)*sigma);

  // Blur it horizontally:
  Func blur_x("blur_x");
  blur_x(x, y, c) = (     input_16(x-n, y, c) +
                      2 * input_16(x, y, c) +
                          input_16(x+n, y, c)) / 4;
  // Blur it vertically:
  Func blur_y("blur_y");
  blur_y(x, y, c) = (     blur_x(x, y-n, c) +
                      2 * blur_x(x, y, c) +
                          blur_x(x, y+n, c)) / 4;

   // Schedule it.
   blur_x.compute_root().vectorize(x, 8).parallel(y);
   blur_y.compute_at(blur_x, y).vectorize(x, 8);


  Func output("output");
  output(x, y, c) = cast<uint8_t>(blur_x(x, y, c));

  out = Halide::Buffer<uint8_t>(input.width()-n*2, input.height()-n*2, 3);
  out.set_min(n, n);

  BENCHMARK("GaussianBlur") {
    output.realize(out);
  };
}

From 146 ms to 1.08 ms for the first case, I guess, I need to try to create an AOT, but, the OpenCV benchmark still being faster than Halide performing the GaussianBlur. I think there must be something wrong with the source code implementation.

-------------------------------------------------------------------------------
GaussianBlur_Halide_1x1
-------------------------------------------------------------------------------
benchmark name                            samples    iterations          mean
-------------------------------------------------------------------------------
GaussianBlur                                   100             1    1.08289 ms 
-------------------------------------------------------------------------------
GaussianBlur_Halide_3x3
-------------------------------------------------------------------------------
benchmark name                            samples    iterations          mean
-------------------------------------------------------------------------------
GaussianBlur                                   100             1    1.08356 ms 
-------------------------------------------------------------------------------
GaussianBlur_Halide_5x5
-------------------------------------------------------------------------------
benchmark name                            samples    iterations          mean
-------------------------------------------------------------------------------
GaussianBlur                                   100             1    1.03509 ms 
-------------------------------------------------------------------------------
GaussianBlur_Halide_7x7
-------------------------------------------------------------------------------
benchmark name                            samples    iterations          mean
-------------------------------------------------------------------------------
GaussianBlur                                   100             1    1.07364 ms 
-------------------------------------------------------------------------------
GaussianBlur_Halide_9x9
-------------------------------------------------------------------------------
benchmark name                            samples    iterations          mean
-------------------------------------------------------------------------------
GaussianBlur                                   100             1     1.0461 ms 

[vksnk]

You still will get it compiled the first time you call output.realize. I think you can avoid that by doing output.compile_jit right before your benchmark:

  output.compile_jit();

  BENCHMARK("GaussianBlur") {
    output.realize(out);
  };

Otherwise, it might be hard to say why OpenCV is faster without knowing the details of their implementation (for example, they might be doing fixed point math instead of floating, approximating something, some other algorithm differences).