Added Image Processing Kernels Using Benchmark Library

[proton]

Summary

I will be adding some more kernels to the same directory (ImageProcessing) using the benchmark library. which will Include
-> Other Dither Kernels
-> Dilate
-> Histogram

Since it will become too big to check if I add all of them together, I am adding some of them for now. Let me know if anyone has any suggestion on kernels that he/she would like to have in llvm-test-suite using benchmark library.

[Meinersbur]

@proton Thank you for the new benchmarks!

IHMO we should have one review and commit per benchmark. This would make it easier to revert an individual benchmark when it fails.

MicroBenchmarks/ImageProcessing/Blur/main.cpp

130

[typo] We read _the_ entire

MicroBenchmarks/ImageProcessing/utils/ImageHelper.cpp

8

Other benchmarks use drand48(). Maybe we should use it as well.

MicroBenchmarks/ImageProcessing/utils/ImageHelper.h

5–10

These should go into the .cpp file.

[proton]

Adding each kernel in separate patches so that it will be easy to review and also we can revert only that kernel which causes problems (if any).

MicroBenchmarks/CMakeLists.txt

   add_subdirectory(XRay)
   add_subdirectory(LCALS)
   add_subdirectory(harris)
-
+  add_subdirectory(ImageProcessing)
 endif()

MicroBenchmarks/ImageProcessing/Blur/CMakeLists.txt

+set(IMAGEPROC_UTILS MicroBenchmarks/ImageProcessing/utils)
+list(APPEND CPPFLAGS -I ${CMAKE_SOURCE_DIR}/${IMAGEPROC_UTILS} -std=c++11 -ffast-math)
+
+
+
+llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh ${CMAKE_CURRENT_BINARY_DIR}/boxBlurOutput.txt")
+llvm_test_verify("${FPCMP} ${CMAKE_CURRENT_BINARY_DIR}/boxBlurOutput.txt ${CMAKE_CURRENT_SOURCE_DIR}/boxBlur.reference_output")
+
+llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh ${CMAKE_CURRENT_BINARY_DIR}/gaussianBlurOutput.txt")
+llvm_test_verify("${FPCMP} ${CMAKE_CURRENT_BINARY_DIR}/gaussianBlurOutput.txt ${CMAKE_CURRENT_SOURCE_DIR}/gaussianBlur.reference_output")
+
+llvm_test_run(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
+
+llvm_test_executable(blur ../utils/ImageHelper.cpp main.cpp boxBlurKernel.cpp gaussianBlurKernel.cpp)
+
+target_link_libraries(blur benchmark)

MicroBenchmarks/ImageProcessing/Blur/blur.h

+#ifndef _BOX_BLUR_H
+#define _BOX_BLUR_H
+
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <stdlib.h>
+
+
+#ifndef HEIGHT
+#define HEIGHT 1024
+#endif
+
+#ifndef WIDTH
+#define WIDTH 1024
+#endif
+
+
+
+// Bigger the box size
+// More is blur
+#define BOX_SIZE 9
+
+void boxBlurKernel(int inputImage[HEIGHT][WIDTH],
+                   int outputImage[HEIGHT][WIDTH], int height, int width);
+void gaussianBlurKernel(int inputImage[HEIGHT][WIDTH],
+                        int outputImage[HEIGHT][WIDTH], int height, int width);
+
+#endif
+// _BOX_BLUR_H end

MicroBenchmarks/ImageProcessing/Blur/boxBlur.reference_output

+d976614a6d0487da6873eb9de4044480

MicroBenchmarks/ImageProcessing/Blur/boxBlurKernel.cpp

+#include "blur.h"
+void boxBlurKernel(int inputImage[HEIGHT][WIDTH],
+                   int outputImage[HEIGHT][WIDTH], int height, int width) {
+  int sum_in_window = 0;
+  int offset = (BOX_SIZE - 1) / 2;
+  int n = BOX_SIZE * BOX_SIZE;
+
+  for (int i = offset; i < height - offset; i++) {
+    for (int j = offset; j < width - offset; j++) {
+      /* Computing sum of elements in window centered at i,j */
+      sum_in_window = 0;
+      for (int k = -1 * offset; k < offset; k++) {
+        for (int l = -1 * offset; l < offset; l++) {
+          sum_in_window += inputImage[i + k][j + l];
+        }
+      }
+      outputImage[i][j] = (sum_in_window) / (n);
+    }
+  }
+}
 No newline at end of file

MicroBenchmarks/ImageProcessing/Blur/gaussianBlur.reference_output

+bf45e940640684676f0175304b9c249a

MicroBenchmarks/ImageProcessing/Blur/gaussianBlurKernel.cpp

+#include "blur.h"
+
+void gaussianBlurKernel(int inputImage[HEIGHT][WIDTH],
+                        int outputImage[HEIGHT][WIDTH], int height, int width) {
+  // Allocating memory for output inputImage
+  int(*__restrict__ img2dblur)[HEIGHT][WIDTH];
+  img2dblur = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) * (HEIGHT) *
+                                                        (WIDTH));
+
+  float sigma = 9;
+  float s = 2.0 * sigma * sigma; // 2 * (sigma)^2
+  int offset = (BOX_SIZE - 1) / 2;
+
+  // generating kernel
+  float sumGaussianKernel = 0;
+  float gaussianFilter[BOX_SIZE][BOX_SIZE] = {0};
+
+  for (int x = -1 * offset; x <= offset; x++) {
+    for (int y = -1 * offset; y <= offset; y++) {
+      gaussianFilter[x + offset][y + offset] =
+          (exp(-(x * x + y * y) / s)) / (M_PI * s);
+      sumGaussianKernel += gaussianFilter[x + offset][y + offset];
+    }
+  }
+
+  float sum_in_window = 0;
+  for (int i = offset; i < height - offset; i++) {
+    for (int j = offset; j < width - offset; j++) {
+      /* Computing sum of elements in window centered at i,j */
+      sum_in_window = 0;
+      for (int k = -1 * offset; k <= offset; k++) {
+        for (int l = -1 * offset; l <= offset; l++) {
+          sum_in_window += (inputImage[i + k][j + l] *
+                            gaussianFilter[k + offset][l + offset]);
+        }
+      }
+      outputImage[i][j] = (sum_in_window) / sumGaussianKernel;
+    }
+  }
+}

MicroBenchmarks/ImageProcessing/Blur/main.cpp

+#include "ImageHelper.h"
+#include "blur.h"
+
+#define BENCHMARK_LIB
+#ifdef BENCHMARK_LIB
+#include "benchmark/benchmark.h"
+#endif
+
+int (*__restrict__ inputImage)[HEIGHT][WIDTH];
+int main(int argc, char *argv[]) {
+
+#ifdef BENCHMARK_LIB
+  ::benchmark::Initialize(&argc, argv);
+#endif
+
+  char *boxBlurOutputFileName = (char *)"./boxBlurOutput.txt";
+  char *gaussianBlurOutputFileName = (char *)"./gaussianBlurOutput.txt";
+
+  inputImage = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) *
+                                                         (HEIGHT) * (WIDTH));
+  initializeRandomImage((int *)(*inputImage), HEIGHT, WIDTH);
+
+// Run Kernels Using Benchmark Library
+#ifdef BENCHMARK_LIB
+  ::benchmark::RunSpecifiedBenchmarks();
+#endif
+
+  // Run Box Blur
+  int(*__restrict__ outputImage)[HEIGHT][WIDTH];
+  outputImage = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) *
+                                                          (HEIGHT) * (WIDTH));
+  boxBlurKernel(*inputImage, *outputImage, HEIGHT, WIDTH);
+
+  // Blur not applied on edges so we add a black border
+  // Otherwise we may get garbage value which may create problem in output
+  // verification
+
+  int offset = (BOX_SIZE - 1) / 2;
+  // Top Edge
+  for (int i = 0; i < offset; i++) {
+    for (int j = 0; j < WIDTH; j++) {
+      (*outputImage)[i][j] = 0;
+    }
+  }
+
+  // Bottom Edge
+  for (int i = HEIGHT - offset; i < HEIGHT; i++) {
+    for (int j = 0; j < WIDTH; j++) {
+      (*outputImage)[i][j] = 0;
+    }
+  }
+
+  // Left Edge
+  for (int i = 0; i < HEIGHT; i++) {
+    for (int j = 0; j < offset; j++) {
+      (*outputImage)[i][j] = 0;
+    }
+  }
+  // Right Edge
+  for (int i = 0; i < HEIGHT; i++) {
+    for (int j = WIDTH - offset; j < WIDTH; j++) {
+      (*outputImage)[i][j] = 0;
+    }
+  }
+
+  saveImage((int *)(*outputImage), boxBlurOutputFileName, HEIGHT, WIDTH);
+  free((void *)outputImage);
+
+  // Run Gaussian Blur
+  outputImage = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) *
+                                                          (HEIGHT) * (WIDTH));
+  gaussianBlurKernel(*inputImage, *outputImage, HEIGHT, WIDTH);
+
+  // Top Edge
+  for (int i = 0; i < offset; i++) {
+    for (int j = 0; j < WIDTH; j++) {
+      (*outputImage)[i][j] = 0;
+    }
+  }
+
+  // Bottom Edge
+  for (int i = HEIGHT - offset; i < HEIGHT; i++) {
+    for (int j = 0; j < WIDTH; j++) {
+      (*outputImage)[i][j] = 0;
+    }
+  }
+
+  // Left Edge
+  for (int i = 0; i < HEIGHT; i++) {
+    for (int j = 0; j < offset; j++) {
+      (*outputImage)[i][j] = 0;
+    }
+  }
+  // Right Edge
+  for (int i = 0; i < HEIGHT; i++) {
+    for (int j = WIDTH - offset; j < WIDTH; j++) {
+      (*outputImage)[i][j] = 0;
+    }
+  }
+
+  saveImage((int *)(*outputImage), gaussianBlurOutputFileName, HEIGHT, WIDTH);
+  free((void *)outputImage);
+
+  free((void *)inputImage);
+  return EXIT_SUCCESS;
+}
+
+#ifdef BENCHMARK_LIB
+void BENCHMARK_boxBlurKernel(benchmark::State &state) {
+
+  int(*__restrict__ outputImage)[HEIGHT][WIDTH];
+  outputImage = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) *
+                                                          (HEIGHT) * (WIDTH));
+  int height = state.range(0);
+  int width = state.range(1);
+  boxBlurKernel(*inputImage, *outputImage, height, width);
+
+  for (auto _ : state) {
+    boxBlurKernel(*inputImage, *outputImage, height, width);
+  }
+
+  if (state.range(0) == 20) {
+    // Anyway should never reach here
+    saveImage((int *)(*outputImage), (char *)"testFailed.txt", HEIGHT, WIDTH);
+  }
+
+  free((void *)outputImage);
+}
+
+// We read entire Image, but only convert a part of image to blur to see how it
+// Scales
+BENCHMARK(BENCHMARK_boxBlurKernel)
+    ->Args({128, 128})
+    ->Args({256, 256})
+    ->Args({512, 512})
+    ->Args({1024, 1024})
+    ->Unit(benchmark::kMicrosecond);
+
+void BENCHMARK_gaussianBlurKernel(benchmark::State &state) {
+
+  int(*__restrict__ outputImage)[HEIGHT][WIDTH];
+  outputImage = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) *
+                                                          (HEIGHT) * (WIDTH));
+  int height = state.range(0);
+  int width = state.range(1);
+  gaussianBlurKernel(*inputImage, *outputImage, height, width);
+
+  for (auto _ : state) {
+    gaussianBlurKernel(*inputImage, *outputImage, height, width);
+  }
+
+  if (state.range(0) == 20) {
+    saveImage((int *)(*outputImage), (char *)"testFailed.txt", HEIGHT, WIDTH);
+  }
+
+  free((void *)outputImage);
+}
+
+BENCHMARK(BENCHMARK_gaussianBlurKernel)
+    ->Args({128, 128})
+    ->Args({256, 256})
+    ->Args({512, 512})
+    ->Args({1024, 1024})
+    ->Unit(benchmark::kMicrosecond);
+#endif

MicroBenchmarks/ImageProcessing/CMakeLists.txt

+add_subdirectory(Blur)
+add_subdirectory(Dither)
+add_subdirectory(Interpolation)
+add_subdirectory(RGBtoGrayScale)
 No newline at end of file

MicroBenchmarks/ImageProcessing/Dither/CMakeLists.txt

+set(IMAGEPROC_UTILS MicroBenchmarks/ImageProcessing/utils)
+list(APPEND CPPFLAGS -I ${CMAKE_SOURCE_DIR}/${IMAGEPROC_UTILS} -std=c++11 -ffast-math)
+
+
+llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh ${CMAKE_CURRENT_BINARY_DIR}/orderedOutput.txt")
+llvm_test_verify("${FPCMP} ${CMAKE_CURRENT_BINARY_DIR}/orderedOutput.txt ${CMAKE_CURRENT_SOURCE_DIR}/orderedDither.reference_output")
+
+llvm_test_run(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
+llvm_test_executable(dither main.cpp orderedDitherKernel.cpp  ../utils/ImageHelper.cpp)
+
+target_link_libraries(dither benchmark)
+
+
+
+

MicroBenchmarks/ImageProcessing/Dither/dither.h

+#ifndef _DITHER_H_
+#define _DITHER_H_
+
+#include <iostream>
+#include <fstream>
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <cstdlib>
+
+
+#define MaxGray   255
+#define MXGRAY    256
+
+
+#define N 16
+#define M 4
+#define GAMMA 0.5
+
+#ifndef HEIGHT
+#define HEIGHT 1024
+#endif
+
+#ifndef WIDTH
+#define WIDTH 1024
+#endif
+
+
+
+void orderedDitherKernel(int inputImage[HEIGHT][WIDTH], int outputImage[HEIGHT][WIDTH], int height, int width);
+#endif 
+// _DITHER_H_ end

MicroBenchmarks/ImageProcessing/Dither/main.cpp

+#include "ImageHelper.h"
+#include "dither.h"
+
+#define BENCHMARK_LIB
+#ifdef BENCHMARK_LIB
+#include "benchmark/benchmark.h"
+#endif
+
+int (*__restrict__ inputImage)[HEIGHT][WIDTH];
+
+using namespace std;
+
+int main(int argc, char **argv) {
+#ifdef BENCHMARK_LIB
+  ::benchmark::Initialize(&argc, argv);
+#endif
+
+  char *orderedOutputFilename = (char *)"./orderedOutput.txt";
+
+  inputImage = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) *
+                                                         (HEIGHT) * (WIDTH));
+
+  initializeRandomImage((int *)(*inputImage), HEIGHT, WIDTH);
+
+#ifdef BENCHMARK_LIB
+  ::benchmark::RunSpecifiedBenchmarks();
+#endif
+
+  int(*__restrict__ outputImage)[HEIGHT][WIDTH];
+  outputImage = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) *
+                                                          (HEIGHT) * (WIDTH));
+  orderedDitherKernel(*inputImage, *outputImage, HEIGHT, WIDTH);
+
+  saveImage((int *)(*outputImage), orderedOutputFilename, HEIGHT, WIDTH);
+
+  free((void *)outputImage);
+  free((void *)inputImage);
+  return 0;
+}
+
+#ifdef BENCHMARK_LIB
+void BENCHMARK_ORDERED_DITHER(benchmark::State &state) {
+  int(*__restrict__ outputImage)[HEIGHT][WIDTH];
+  outputImage = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) *
+                                                          (HEIGHT) * (WIDTH));
+  int height = state.range(0);
+  int width = state.range(1);
+  orderedDitherKernel(*inputImage, *outputImage, height, width);
+
+  for (auto _ : state) {
+    orderedDitherKernel(*inputImage, *outputImage, height, width);
+  }
+
+  if (state.range(0) == 20) {
+    saveImage((int *)(*outputImage), (char *)"failedCase.txt", HEIGHT, WIDTH);
+  }
+
+  free((void *)outputImage);
+}
+BENCHMARK(BENCHMARK_ORDERED_DITHER)
+    ->Args({128, 128})
+    ->Args({256, 256})
+    ->Args({512, 512})
+    ->Args({1024, 1024})
+    ->Unit(benchmark::kMicrosecond);
+#endif
 No newline at end of file

MicroBenchmarks/ImageProcessing/Dither/orderedDither.reference_output

+c36c928731bafb3568f0f7c6c24a99be

MicroBenchmarks/ImageProcessing/Dither/orderedDitherKernel.cpp

+#include "dither.h"
+void orderedDitherKernel(int inputImage[HEIGHT][WIDTH],
+                         int outputImage[HEIGHT][WIDTH], int height,
+                         int width) {
+  int scale;
+
+  // initialize the dither matrices
+  int dither2[2][2] = {{0, 2}, {3, 1}};
+
+  int dither3[3][3] = {{6, 8, 4}, {1, 0, 3}, {5, 2, 7}};
+
+  int dither4[4][4] = {
+      {0, 8, 2, 10}, {12, 4, 14, 6}, {3, 11, 1, 9}, {15, 7, 13, 5}};
+
+  int dither8[8][8] = {
+      {0, 48, 12, 60, 3, 51, 15, 63}, {32, 16, 44, 28, 35, 19, 47, 31},
+      {8, 56, 4, 52, 11, 59, 7, 55},  {40, 24, 36, 20, 43, 27, 39, 23},
+      {2, 50, 14, 62, 1, 49, 13, 61}, {34, 18, 46, 30, 33, 17, 45, 29},
+      {10, 58, 6, 54, 9, 57, 5, 53},  {42, 26, 38, 22, 41, 25, 37, 21}};
+
+  int(*__restrict__ tmp_out)[HEIGHT][WIDTH];
+  tmp_out = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) * (HEIGHT) *
+                                                      (WIDTH));
+
+  if (tmp_out == NULL) {
+    std::cerr << "Insufficient memory\n";
+    exit(1);
+  }
+
+  // this should produce gamma corrected image from look up table.
+  // and store the image in tmp_out;
+  for (int i = 0; i < height; i++) {
+    for (int j = 0; j < width; j++) {
+      (*tmp_out)[i][j] =
+          (int)(pow((double)inputImage[i][j] / 255.0, (1.0 / GAMMA)) * 255.0);
+    }
+  }
+
+  scale = 256 / N;
+  for (int i = 0; i < height; i++) {
+    for (int j = 0; j < width; j++) {
+      outputImage[i][j] = (int)(scale * ((*tmp_out)[i][j] / scale)) / scale;
+    }
+  }
+
+  for (int y = 0; y < height; y++) {
+    for (int x = 0; x < width; x++) {
+      int i = x % M;
+      int j = y % M;
+      if (M == 2) {
+        outputImage[y][x] = ((outputImage[y][x] > dither2[i][j]) ? 255 : 0);
+      } else if (M == 3) {
+        outputImage[y][x] = ((outputImage[y][x] > dither3[i][j]) ? 255 : 0);
+      } else if (M == 4) {
+        outputImage[y][x] = ((outputImage[y][x] > dither4[i][j]) ? 255 : 0);
+      } else if (M == 8) {
+        outputImage[y][x] = ((outputImage[y][x] > dither8[i][j]) ? 255 : 0);
+      } else {
+        std::cerr
+            << " Error: selected M not allowed, choose M from [2, 3, 4, 8]\n";
+      }
+    }
+  }
+}

MicroBenchmarks/ImageProcessing/Interpolation/CMakeLists.txt

+set(IMAGEPROC_UTILS MicroBenchmarks/ImageProcessing/utils)
+list(APPEND CPPFLAGS -I ${CMAKE_SOURCE_DIR}/${IMAGEPROC_UTILS} -std=c++11 -ffast-math)
+
+llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh ${CMAKE_CURRENT_BINARY_DIR}/bicubicOutput.txt")
+llvm_test_verify("${FPCMP} ${CMAKE_CURRENT_BINARY_DIR}/bicubicOutput.txt ${CMAKE_CURRENT_SOURCE_DIR}/bicubic.reference_output")
+
+llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh ${CMAKE_CURRENT_BINARY_DIR}/bilinearOutput.txt")
+llvm_test_verify("${FPCMP} ${CMAKE_CURRENT_BINARY_DIR}/bilinearOutput.txt ${CMAKE_CURRENT_SOURCE_DIR}/bilinear.reference_output")
+
+llvm_test_run(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
+llvm_test_executable(interpolation bicubicKernel.cpp bilinearKernel.cpp main.cpp ../utils/ImageHelper.cpp)
+target_link_libraries(interpolation benchmark)

MicroBenchmarks/ImageProcessing/Interpolation/bicubic.reference_output

+85b325b971e5244594e462adc2c81f48

MicroBenchmarks/ImageProcessing/Interpolation/bicubicKernel.cpp

+#include "interpolation.h"
+// bicubic-interpolation-image-processing... github/google code archive
+void bicubicKernel(int inputImage[HEIGHT][WIDTH],
+                   int outputImage[NEWHEIGHT][NEWWIDTH], int height,
+                   int width) {
+  float Cc;
+  float C[5] = {0};
+  float a, b, c, d, e, f, g;
+  int x, y;
+
+  const int newheight = ZOOM * height;
+  const int newwidth = ZOOM * width;
+
+  // const float tx = (float)1/(float)ZOOM;
+  // const float ty = (float)1/(float)ZOOM;
+  for (int i = 0; i < newheight; i++) {
+    for (int j = 0; j < newwidth; j++) {
+      y = i / ZOOM;
+      x = j / ZOOM;
+
+      const float dx = j / (float)ZOOM - x;
+      const float dy = i / (float)ZOOM - y;
+
+      for (int jj = 0; jj <= 3; jj++) {
+
+        // These if//else to make sure we are in array bounds...
+        if ((y + jj - 1) < 0) {
+          a = 0;
+          b = 0;
+          c = 0;
+          d = 0;
+        } else if ((x - 1) < 0) {
+          a = inputImage[y + jj - 1][x];
+          b = -1 * a;
+          c = inputImage[y + jj - 1][x + 1] - a;
+          d = inputImage[y + jj - 1][x + 2] - a;
+        } else if ((x + 1) >= width) {
+          a = inputImage[y + jj - 1][x];
+          b = inputImage[y + jj - 1][x - 1] - a;
+          c = -1 * a;
+          d = inputImage[y + jj - 1][x + 2] - a;
+        } else if ((x + 2) >= width) {
+          a = inputImage[y + jj - 1][x];
+          b = inputImage[y + jj - 1][x - 1] - a;
+          c = inputImage[y + jj - 1][x + 1] - a;
+          d = -1 * a;
+        } else {
+          a = inputImage[y + jj - 1][x];
+          b = inputImage[y + jj - 1][x - 1] - a;
+          c = inputImage[y + jj - 1][x + 1] - a;
+          d = inputImage[y + jj - 1][x + 2] - a;
+        }
+
+        e = -1.0 / 3 * b + c - 1.0 / 6 * d;
+        f = 1.0 / 2 * b + 1.0 / 2 * c;
+        g = -1.0 / 6 * b - 1.0 / 2 * c + 1.0 / 6 * d;
+
+        C[jj] = a + e * dx + f * dx * dx + g * dx * dx * dx;
+
+        a = C[1];
+        b = C[0] - C[1];
+        c = C[2] - C[1];
+        d = C[3] - C[1];
+
+        e = -1.0 / 3 * b + c - 1.0 / 6 * d;
+        f = 1.0 / 2 * b + 1.0 / 2 * c;
+        g = -1.0 / 6 * b - 1.0 / 2 * c + 1.0 / 6 * d;
+
+        Cc = a + e * dy + f * dy * dy + g * dy * dy * dy;
+
+        outputImage[i][j] = (int)Cc;
+      }
+    }
+  }
+}

MicroBenchmarks/ImageProcessing/Interpolation/bilinear.reference_output

+ae0245749e85e1bb6674515250308a75

MicroBenchmarks/ImageProcessing/Interpolation/bilinearKernel.cpp

+#include "interpolation.h"
+
+void bilinearKernel(int inputImage[HEIGHT][WIDTH],
+                    int outputImage[NEWHEIGHT][NEWWIDTH], int height,
+                    int width) {
+  int x, y;
+
+  // float tx = (float)NEWWIDTH/(WIDTH);
+  // float ty = (float)NEWHEIGHT/(HEIGHT);
+
+  float x_diff, y_diff;
+  int i, j;
+  int newHeight = ZOOM * height;
+  int newWidth = ZOOM * width;
+
+  for (i = 0; i < newHeight; i++) {
+    for (j = 0; j < newWidth; j++) {
+      x = j / ZOOM;
+      y = i / ZOOM;
+
+      x_diff = ((j / (float)ZOOM) - x);
+      y_diff = ((i / (float)ZOOM) - y);
+      if ((x + 1) < width && (y + 1) < height) {
+        outputImage[i][j] = inputImage[y][x] * (1 - x_diff) * (1 - y_diff) +
+                            inputImage[y][x + 1] * (1 - y_diff) * (x_diff) +
+                            inputImage[y + 1][x] * (y_diff) * (1 - x_diff) +
+                            inputImage[y + 1][x + 1] * (y_diff) * (x_diff);
+      } else if ((x + 1) < width) {
+        outputImage[i][j] = inputImage[y][x] * (1 - x_diff) * (1 - y_diff) +
+                            inputImage[y][x + 1] * (1 - y_diff) * (x_diff);
+      } else {
+        outputImage[i][j] = inputImage[y][x] * (1 - x_diff) * (1 - y_diff) +
+                            inputImage[y + 1][x] * (y_diff) * (1 - x_diff);
+      }
+    }
+  }
+}
 No newline at end of file

MicroBenchmarks/ImageProcessing/Interpolation/interpolation.h

+#ifndef _INTERPOLATION_H_
+#define _INTERPOLATION_H_
+
+#include <iostream>
+#include <fstream>
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <cstdlib>
+
+#ifndef HEIGHT
+#define HEIGHT 1024
+#endif
+
+#ifndef WIDTH
+#define WIDTH 1024
+#endif
+
+
+#define OLDHEIGHT HEIGHT
+#define OLDWIDTH WIDTH
+
+// 4x zoom
+// ZOOM > 1 ....
+#define ZOOM 4
+
+#define NEWHEIGHT (int)(ZOOM*HEIGHT)
+#define NEWWIDTH (int)(ZOOM*WIDTH)
+
+void bicubicKernel(int inputImage[HEIGHT][WIDTH], int outputImage[NEWHEIGHT][NEWWIDTH], int height, int width);
+void bilinearKernel(int inputImage[HEIGHT][WIDTH], int outputImage[NEWHEIGHT][NEWWIDTH], int height, int width);
+
+#endif
+// _INTERPOLATION_H_ end

MicroBenchmarks/ImageProcessing/Interpolation/main.cpp

+#include "ImageHelper.h"
+#include "interpolation.h"
+
+#define BENCHMARK_LIB
+#ifdef BENCHMARK_LIB
+#include "benchmark/benchmark.h"
+#endif
+
+int (*__restrict__ inputImage)[HEIGHT][WIDTH];
+
+int main(int argc, char **argv) {
+#ifdef BENCHMARK_LIB
+  ::benchmark::Initialize(&argc, argv);
+#endif
+
+  char *bicubicOutputFilename = (char *)"./bicubicOutput.txt";
+  char *bilinearOutputFileName = (char *)"./bilinearOutput.txt";
+
+  inputImage = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) *
+                                                         (HEIGHT) * (WIDTH));
+
+  int(*__restrict__ outputImage)[NEWHEIGHT][NEWWIDTH];
+  outputImage = (int(*__restrict__)[NEWHEIGHT][NEWWIDTH])malloc(
+      sizeof(int) * (NEWHEIGHT) * (NEWWIDTH));
+
+  initializeRandomImage((int *)*inputImage, HEIGHT, WIDTH);
+
+#ifdef BENCHMARK_LIB
+  ::benchmark::RunSpecifiedBenchmarks();
+#endif
+
+  bicubicKernel(*inputImage, *outputImage, HEIGHT, WIDTH);
+
+  saveImage((int *)(*outputImage), bicubicOutputFilename, NEWHEIGHT, NEWWIDTH);
+
+  free((void *)outputImage);
+
+  outputImage = (int(*__restrict__)[NEWHEIGHT][NEWWIDTH])malloc(
+      sizeof(int) * (NEWHEIGHT) * (NEWWIDTH));
+  bilinearKernel(*inputImage, *outputImage, HEIGHT, WIDTH);
+
+  saveImage((int *)(*outputImage), bilinearOutputFileName, NEWHEIGHT, NEWWIDTH);
+
+  free((void *)inputImage);
+  free((void *)outputImage);
+  return 0;
+}
+
+#ifdef BENCHMARK_LIB
+void BENCHMARK_BICUBIC_INTERPOLATION(benchmark::State &state) {
+  int(*__restrict__ outputImage)[NEWHEIGHT][NEWWIDTH];
+  outputImage = (int(*__restrict__)[NEWHEIGHT][NEWWIDTH])malloc(
+      sizeof(int) * (NEWHEIGHT) * (NEWWIDTH));
+  int height = state.range(0);
+  int width = state.range(1);
+  bicubicKernel(*inputImage, *outputImage, height, width);
+
+  for (auto _ : state) {
+    bicubicKernel(*inputImage, *outputImage, height, width);
+  }
+
+  if (state.range(0) == 20) {
+    saveImage((int *)(*outputImage), (char *)"failedCase.txt", NEWHEIGHT,
+              NEWWIDTH);
+  }
+
+  free((void *)outputImage);
+}
+BENCHMARK(BENCHMARK_BICUBIC_INTERPOLATION)
+    ->Args({64, 64})
+    ->Args({128, 128})
+    ->Args({256, 256})
+    ->Args({512, 512})
+    ->Unit(benchmark::kMicrosecond);
+
+void BENCHMARK_BILINEAR_INTERPOLATION(benchmark::State &state) {
+  int(*__restrict__ outputImage)[NEWHEIGHT][NEWWIDTH];
+  outputImage = (int(*__restrict__)[NEWHEIGHT][NEWWIDTH])malloc(
+      sizeof(int) * (NEWHEIGHT) * (NEWWIDTH));
+  int height = state.range(0);
+  int width = state.range(1);
+  bilinearKernel(*inputImage, *outputImage, height, width);
+
+  for (auto _ : state) {
+    bilinearKernel(*inputImage, *outputImage, height, width);
+  }
+
+  if (state.range(0) == 20) {
+    saveImage((int *)(*outputImage), (char *)"failedCase.txt", NEWHEIGHT,
+              NEWWIDTH);
+  }
+
+  free((void *)outputImage);
+}
+BENCHMARK(BENCHMARK_BILINEAR_INTERPOLATION)
+    ->Args({64, 64})
+    ->Args({128, 128})
+    ->Args({256, 256})
+    ->Args({512, 512})
+    ->Unit(benchmark::kMicrosecond);
+
+#endif
 No newline at end of file

MicroBenchmarks/ImageProcessing/RGBtoGrayScale/CMakeLists.txt

+set(IMAGEPROC_UTILS MicroBenchmarks/ImageProcessing/utils)
+list(APPEND CPPFLAGS -I ${CMAKE_SOURCE_DIR}/${IMAGEPROC_UTILS} -std=c++11 -ffast-math)
+
+llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh ${CMAKE_CURRENT_BINARY_DIR}/grayImage.txt")
+llvm_test_verify("${FPCMP} ${CMAKE_CURRENT_BINARY_DIR}/grayImage.txt ${CMAKE_CURRENT_SOURCE_DIR}/cvtcolor.reference_output")
+
+
+llvm_test_run(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
+llvm_test_executable(cvtColor cvtColorKernel.cpp main.cpp ../utils/ImageHelper.cpp)
+
+target_link_libraries(cvtColor benchmark)
+
+
+
+
+

MicroBenchmarks/ImageProcessing/RGBtoGrayScale/cvtColor.h

+#ifndef _BOX_BLUR_H
+#define _BOX_BLUR_H
+
+#include <iostream>
+#include <cmath>
+#include <stdlib.h>
+#include <fstream>
+
+#ifndef HEIGHT
+#define HEIGHT 1024
+#endif
+
+#ifndef WIDTH
+#define WIDTH 1024
+#endif
+
+
+void rgbToGray(int inputImage[HEIGHT][WIDTH][3], int outputImage[HEIGHT][WIDTH], int height, int width);
+
+#endif
+// _BOX_BLUR_H end

MicroBenchmarks/ImageProcessing/RGBtoGrayScale/cvtColorKernel.cpp

+#include "cvtColor.h"
+
+// Using Averaging
+void rgbToGray(int inputImage[HEIGHT][WIDTH][3], int outputImage[HEIGHT][WIDTH],
+               int height, int width) {
+  for (int i = 0; i < height; i++) {
+    for (int j = 0; j < width; j++) {
+      // 0.21 R + 0.72 G + 0.07 B
+      outputImage[i][j] = 0.21 * inputImage[i][j][0] +
+                          0.72 * inputImage[i][j][1] +
+                          0.07 * inputImage[i][j][2];
+    }
+  }
+}

MicroBenchmarks/ImageProcessing/RGBtoGrayScale/cvtcolor.reference_output

+d1032182b69683b2596411df8040a3d7

MicroBenchmarks/ImageProcessing/RGBtoGrayScale/main.cpp

+#include "ImageHelper.h"
+#include "cvtColor.h"
+
+#define BENCHMARK_LIB
+#ifdef BENCHMARK_LIB
+#include "benchmark/benchmark.h"
+#endif
+
+int (*__restrict__ inputImage)[HEIGHT][WIDTH][3];
+int main(int argc, char *argv[]) {
+#ifdef BENCHMARK_LIB
+  ::benchmark::Initialize(&argc, argv);
+#endif
+
+  char *grayImageOutput = (char *)"./grayImage.txt";
+
+  inputImage = (int(*__restrict__)[HEIGHT][WIDTH][3])malloc(
+      sizeof(int) * (HEIGHT) * (WIDTH) * (3));
+
+  initializeRandomColouredImage((int *)*inputImage, HEIGHT, WIDTH);
+
+// Run Kernels Using Benchmark Library
+#ifdef BENCHMARK_LIB
+  ::benchmark::RunSpecifiedBenchmarks();
+#endif
+
+  // Run Box Blur
+  int(*__restrict__ outputImage)[HEIGHT][WIDTH];
+  outputImage = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) *
+                                                          (HEIGHT) * (WIDTH));
+
+  rgbToGray(*inputImage, *outputImage, HEIGHT, WIDTH);
+
+  saveImage((int*)(*outputImage), grayImageOutput, HEIGHT, WIDTH);
+  free((void *)outputImage);
+
+  return EXIT_SUCCESS;
+}
+
+#ifdef BENCHMARK_LIB
+void BENCHMARK_RGBTOGRAYSCALE(benchmark::State &state) {
+
+  int(*__restrict__ outputImage)[HEIGHT][WIDTH];
+  outputImage = (int(*__restrict__)[HEIGHT][WIDTH])malloc(sizeof(int) *
+                                                          (HEIGHT) * (WIDTH));
+  int height = state.range(0);
+  int width = state.range(1);
+  rgbToGray(*inputImage, *outputImage, height, width);
+
+  for (auto _ : state) {
+    rgbToGray(*inputImage, *outputImage, height, width);
+  }
+
+  if (state.range(0) == 20) {
+    // Anyway should never reach here
+    saveImage((int*)(*outputImage), (char *)"testFailed.txt", HEIGHT, WIDTH);
+  }
+
+  free((void *)outputImage);
+}
+
+// We read entire Image, but only convert a part of image to blur to see how it
+// Scales
+BENCHMARK(BENCHMARK_RGBTOGRAYSCALE)
+    ->Args({128, 128})
+    ->Args({256, 256})
+    ->Args({512, 512})
+    ->Args({1024, 1024})
+    ->Unit(benchmark::kMicrosecond);
+#endif

MicroBenchmarks/ImageProcessing/utils/ImageHelper.h

+#ifndef _IMAGEHELPER_H_
+#define _IMAGEHELPER_H_
+
+// This File contains some helper functions to initialize 
+#include <iostream>
+#include <fstream>
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <cstdlib>
+
+
+void initializeRandomImage(int *image, int height, int width);
+void initializeRandomColouredImage(int *image, int height, int width);
+void saveImage(int *image, char *outputFile, int height, int width);
+
+#endif
+//_IMAGEHELPER_H_ end

MicroBenchmarks/ImageProcessing/utils/ImageHelper.cpp

+#include "ImageHelper.h"
+
+// Initializes a random Image
+void initializeRandomImage(int *image, int height, int width) {
+  srand(7);
+  for (int i = 0; i < height; i++) {
+    for (int j = 0; j < width; j++) {
+      image[i * width + j] = rand() % 256;
+    }
+  }
+}
+
+void saveImage(int *image, char *outputFile, int height, int width) {
+  std::ofstream outfile;
+  outfile.open(outputFile, std::ios::out | std::ios::trunc);
+
+  for (int i = 0; i < height; i++) {
+    for (int j = 0; j < width; j++) {
+      // Just for safety
+      if (image[i * width + j] > 255) {
+        outfile << 255 << " ";
+        ;
+      } else if (image[i * width + j] < 0) {
+        outfile << 0 << " ";
+        ;
+      } else {
+        outfile << image[i * width + j] << " ";
+        ;
+      }
+    }
+    outfile << std::endl;
+  }
+}
+
+// Initializes a random Image
+void initializeRandomColouredImage(int *image, int height, int width) {
+  srand(7);
+  for (int i = 0; i < height; i++) {
+    for (int j = 0; j < width; j++) {
+      image[i * (width * 3) + j * 3 + 0] = rand() % 256;
+      image[i * (width * 3) + j * 3 + 1] = rand() % 256;
+      image[i * (width * 3) + j * 3 + 2] = rand() % 256;
+    }
+  }
+}
 No newline at end of file