[test-suite] Add Bilateral Filter kernel using benchmark library

[proton]

Summary

This patch adds BilateralFiltering kernel in "MicroBenchmarks/ImageProcessing"

Runtime

Without Polly: Total 0m5.542s

Benchmark	Time	CPU	Iterations
BENCHMARK_BILATERAL_FILTER/16/2	40 us	40 us	17339
BENCHMARK_BILATERAL_FILTER/16/4	131 us	131 us	5361
BENCHMARK_BILATERAL_FILTER/32/2	164 us	164 us	4267
BENCHMARK_BILATERAL_FILTER/32/4	632 us	632 us	1109
BENCHMARK_BILATERAL_FILTER/64/2	700 us	700 us	1000
BENCHMARK_BILATERAL_FILTER/64/4	3286 us	3285 us	213

With Polly : Total 0m5.577s

Benchmark	Time	CPU	Iterations
BENCHMARK_BILATERAL_FILTER/16/2	41 us	41 us	16945
BENCHMARK_BILATERAL_FILTER/16/4	134 us	134 us	5248
BENCHMARK_BILATERAL_FILTER/32/2	168 us	168 us	4175
BENCHMARK_BILATERAL_FILTER/32/4	647 us	647 us	1071
BENCHMARK_BILATERAL_FILTER/64/2	716 us	716 us	978
BENCHMARK_BILATERAL_FILTER/64/4	2963 us	2963 us	236

Even after repeated runs, this small difference in runtime is there. For input (32/4) and (64/4), Polly always performed better.

[Meinersbur]

Should the total execution time of benchmarks be around second or less?
Maybe reduce the number of tested parameters to reduce the total runtime?

[proton]

Reduced test size
Total runtime is still there for about 5.5s (with benchmark library) because the benchmark library runs kernel for multiple inputs.

Without benchmark library
For input 128/5, the kernel runs for around 0.028s of total 0.034s.

MicroBenchmarks/ImageProcessing/BilateralFiltering/CMakeLists.txt

+set(IMAGEPROC_UTILS MicroBenchmarks/ImageProcessing/utils)
+list(APPEND CPPFLAGS -I ${CMAKE_SOURCE_DIR}/${IMAGEPROC_UTILS})
+list(APPEND LDFLAGS -lm)
+
+llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh ${CMAKE_CURRENT_BINARY_DIR}/bilateralFilterOutput.txt")
+llvm_test_verify("${FPCMP} ${CMAKE_CURRENT_BINARY_DIR}/bilateralFilterOutput.txt ${CMAKE_CURRENT_SOURCE_DIR}/bilateralFilter.reference_output")
+
+llvm_test_run(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
+llvm_test_executable(BilateralFilter ../utils/ImageHelper.cpp ../utils/glibc_compat_rand.c main.cpp bilateralFilterKernel.c)
+
+target_link_libraries(BilateralFilter benchmark)

MicroBenchmarks/ImageProcessing/BilateralFiltering/bilateralFilter.reference_output

+2a6f2dde40535316d0c4d1936151a8df

MicroBenchmarks/ImageProcessing/BilateralFiltering/bilateralFilterKernel.c

+/**
+  Source: https://github.com/anlcnydn/bilateral
+  Modified by
+  Pankaj Kukreja
+  Indian Institute of technology, Hyderabad
+*/
+#include "bilateralFiltering.h"
+#include <math.h>
+
+#define sigmaI 12.0
+#define sigmaS 16.0
+
+#define GAUSSIAN(x, sigma)                                                     \
+  (exp(-(x * x) / (2 * sigma * sigma)) / (2 * M_PI * (sigma * sigma)))
+
+void bilateralFilterKernel(int height, int width, int inputImage[HEIGHT][WIDTH],
+                           int outputImage[height][width], int diameter) {
+  int half = diameter / 2;
+  for (int x = half; x < height - half; x++) {
+    for (int y = half; y < width - half; y++) {
+      double iFiltered = 0;
+      double wP = 0;
+      int neighbor_x = 0;
+      int neighbor_y = 0;
+      for (int i = 0; i < diameter; i++) {
+        for (int j = 0; j < diameter; j++) {
+          neighbor_x = x - (half - i);
+          neighbor_y = y - (half - j);
+          double gi = GAUSSIAN(
+              inputImage[neighbor_x][neighbor_y] - inputImage[x][y], sigmaI);
+          double gs =
+              GAUSSIAN((float)(sqrt(((x - neighbor_x) * (x - neighbor_x)) +
+                                    ((y - neighbor_y) * (y - neighbor_y)))),
+                       sigmaS);
+          double w = gi * gs;
+          iFiltered = iFiltered + inputImage[neighbor_x][neighbor_y] * w;
+          wP = wP + w;
+        }
+      }
+      iFiltered = iFiltered / wP;
+      outputImage[x][y] = iFiltered;
+    }
+  }
+}
 No newline at end of file

MicroBenchmarks/ImageProcessing/BilateralFiltering/bilateralFiltering.h

+/**
+  Pankaj Kukreja
+  github.com/proton0001
+  Indian Institute of Technology Hyderabad
+*/
+
+#ifndef _BILATERAL_FILTERING_H_
+#define _BILATERAL_FILTERING_H_
+
+#define HEIGHT 256
+#define WIDTH 256
+#define DIAMETER 5
+
+#endif /* _BILATERAL_FILTERING_H_ */

MicroBenchmarks/ImageProcessing/BilateralFiltering/main.cpp

+/**
+  Pankaj Kukreja
+  github.com/proton0001
+  Indian Institute of Technology Hyderabad
+*/
+
+#include "ImageHelper.h"
+#include "bilateralFiltering.h"
+#include <iostream> // std::cerr
+
+#define BENCHMARK_LIB
+#ifdef BENCHMARK_LIB
+#include "benchmark/benchmark.h"
+#endif
+
+int *inputImage;
+extern "C" void bilateralFilterKernel(int height, int width, int *inputImage,
+                                      int *outputImage, int diameter);
+
+int main(int argc, char *argv[]) {
+
+#ifdef BENCHMARK_LIB
+  ::benchmark::Initialize(&argc, argv);
+#endif
+
+  const char *bilateralFilterOutputFileName =
+      (const char *)"./bilateralFilterOutput.txt";
+
+  inputImage = (int *)malloc(sizeof(int) * (HEIGHT) * (WIDTH));
+
+  if (inputImage == NULL) {
+    std::cerr << "Insufficient memory\n";
+    exit(EXIT_FAILURE);
+  }
+
+  initializeRandomImage(inputImage, HEIGHT, WIDTH);
+
+#ifdef BENCHMARK_LIB
+  ::benchmark::RunSpecifiedBenchmarks();
+#endif
+
+  int *outputImage = (int *)malloc(sizeof(int) * (HEIGHT) * (WIDTH));
+  if (outputImage == NULL) {
+    std::cerr << "Insufficient memory\n";
+    exit(EXIT_FAILURE);
+  }
+  for (int i = 0; i < HEIGHT; i++) {
+    for (int j = 0; j < WIDTH; j++) {
+      outputImage[i * WIDTH + j] = 0;
+    }
+  }
+
+  bilateralFilterKernel(HEIGHT, WIDTH, inputImage, outputImage, DIAMETER);
+
+  saveImage(outputImage, bilateralFilterOutputFileName, HEIGHT, WIDTH);
+
+  free(outputImage);
+  free(inputImage);
+  return (EXIT_SUCCESS);
+}
+
+#ifdef BENCHMARK_LIB
+void BENCHMARK_BILATERAL_FILTER(benchmark::State &state) {
+
+  int height = state.range(0);
+  int width = state.range(0);
+  int diameter = state.range(1);
+
+  int *outputImage = (int *)malloc(sizeof(int) * (height) * (width));
+  if (outputImage == NULL) {
+    std::cerr << "Insufficient memory\n";
+    exit(EXIT_FAILURE);
+  }
+  /* first call made to warm up the cache*/
+  bilateralFilterKernel(height, width, inputImage, outputImage, diameter);
+  while (state.KeepRunning()) {
+    bilateralFilterKernel(height, width, inputImage, outputImage, diameter);
+  }
+  /* Since we are not passing state.range as 20 this if case will always be
+   * false. This call is to make compiler think that outputImage may be used
+   * later so that above kernel calls will not get optimize out */
+  if (state.range(0) == 20) {
+    saveImage(outputImage, (const char *)"testFailed.txt", height, width);
+  }
+
+  free(outputImage);
+}
+
+#if (HEIGHT < WIDTH)
+#define MINIMUM_DIM HEIGHT
+#else
+#define MINIMUM_DIM WIDTH
+#endif
+static void CustomArguments(benchmark::internal::Benchmark *b) {
+  int limit = MINIMUM_DIM;
+  int start = 16;
+  if (start > limit) {
+    start = 1;
+  }
+  for (int i = start; i < limit; i <<= 1) {
+    b->ArgPair(i, 2);
+    b->ArgPair(i, 4);
+    b->ArgPair(i, 8);
+  }
+}
+BENCHMARK(BENCHMARK_BILATERAL_FILTER)
+    ->Apply(CustomArguments)
+    ->Unit(benchmark::kMicrosecond);
+#endif

MicroBenchmarks/ImageProcessing/CMakeLists.txt

 add_subdirectory(Dither)
 add_subdirectory(AnisotropicDiffusion)
 add_subdirectory(Interpolation)
 add_subdirectory(Blur)
+add_subdirectory(BilateralFiltering)