Add REPLICATE_PADDING boundary option in image_processing_benchmark (#39)

* Added REPLICATE_PADDING boundary option

* Added CLI argument for selecting boundary option Corr2D

* Updated Documentation of README.md

* Formatting fixes and type casting the CLI argument

* Added OpenCV BORDER_REPLICATE benchmarking

* Updated type of variable to BoundaryOption

README.md

@@ -45,7 +45,9 @@ Run the image processing benchmark:
 *ii. Please replace `<kernel name>` with name of the kernel which is to be used for*
 *benchmarking as specifed in `include/ImageProcessing/Kernels.h`.*
 
-Ex. `./image-processing-benchmark ../../benchmarks/ImageProcessing/Images/YuTu.png laplacianKernelAlign`
+*iii. Please replace `<Boundary Option>` with `CONSTANT_PADDING` or `REPLICATE_PADDING`.*
+
+Ex. `./image-processing-benchmark ../../benchmarks/ImageProcessing/Images/YuTu.png laplacianKernelAlign CONSTANT_PADDING`
 ```
 $ cd buddy-benchmark
 $ mkdir build && cd build
@@ -55,7 +57,7 @@ $ cmake -G Ninja .. \
     -DEIGEN_DIR=/PATH/TO/EIGEN/SOURCE/CODE \
     -DBUDDY_OPT_BUILD_DIR=/PATH/TO/BUDDY-MLIR/BUILD/
 $ ninja image-processing-benchmark
-$ cd bin && ./image-processing-benchmark <image path> <kernel name>
+$ cd bin && ./image-processing-benchmark <image path> <kernel name> <Boundary Option>
 ```
 
 ## Deep Learning Benchmark

benchmarks/ImageProcessing/BuddyCorr2D.mlir

@@ -27,3 +27,13 @@ func.func @corr_2d_constant_padding(%inputImage : memref<?x?xf32>, %kernel : mem
               index, f32
   return
 }
+
+func.func @corr_2d_replicate_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, 
+                               %outputImage : memref<?x?xf32>, %centerX : index, 
+                               %centerY : index, %constantValue : f32) {
+  dip.corr_2d REPLICATE_PADDING %inputImage, %kernel, %outputImage, %centerX, 
+              %centerY , %constantValue : 
+              memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, 
+              index, f32
+  return
+}

benchmarks/ImageProcessing/BuddyCorr2DBenchmark.cpp

@@ -34,6 +34,13 @@ void _mlir_ciface_corr_2d_constant_padding(MemRef<float, 2> *inputBuddyCorr2D,
                                            unsigned int centerX,
                                            unsigned int centerY,
                                            float constantValue);
+
+void _mlir_ciface_corr_2d_replicate_padding(MemRef<float, 2> *inputBuddyCorr2D,
+                                            MemRef<float, 2> *kernelBuddyCorr2D,
+                                            MemRef<float, 2> *outputBuddyCorr2D,
+                                            unsigned int centerX,
+                                            unsigned int centerY,
+                                            float constantValue);
 }
 
 // Declare input image and kernel.
@@ -50,6 +57,12 @@ intptr_t sizesInputBuddyCorr2D[2];
 intptr_t sizesKernelBuddyCorr2D[2];
 intptr_t sizesOutputBuddyCorr2D[2];
 
+// Declare Boundary Options supported.
+enum BoundaryOption { constant_padding, replicate_padding };
+
+// Define Boundary option selected.
+BoundaryOption BoundaryType;
+
 void initializeBuddyCorr2D(char **argv) {
   inputImageBuddyCorr2D = imread(argv[1], IMREAD_GRAYSCALE);
   kernelBuddyCorr2DMat =
@@ -70,9 +83,15 @@ void initializeBuddyCorr2D(char **argv) {
 
   sizesOutputBuddyCorr2D[0] = outputRowsBuddyCorr2D;
   sizesOutputBuddyCorr2D[1] = outputColsBuddyCorr2D;
+
+  if (static_cast<string>(argv[3]) == "REPLICATE_PADDING") {
+    BoundaryType = replicate_padding;
+  } else {
+    BoundaryType = constant_padding;
+  }
 }
 
-static void Buddy_Corr2D(benchmark::State &state) {
+static void Buddy_Corr2D_Constant_Padding(benchmark::State &state) {
   // Define the MemRef descriptor for input, kernel, and output.
   MemRef<float, 2> inputBuddyCorr2D(inputImageBuddyCorr2D,
                                     sizesInputBuddyCorr2D);
@@ -89,8 +108,31 @@ static void Buddy_Corr2D(benchmark::State &state) {
   }
 }
 
+static void Buddy_Corr2D_Replicate_Padding(benchmark::State &state) {
+  // Define the MemRef descriptor for input, kernel, and output.
+  MemRef<float, 2> inputBuddyCorr2D(inputImageBuddyCorr2D,
+                                    sizesInputBuddyCorr2D);
+  MemRef<float, 2> kernelBuddyCorr2D(kernelBuddyCorr2DMat,
+                                     sizesKernelBuddyCorr2D);
+  MemRef<float, 2> outputBuddyCorr2D(sizesOutputBuddyCorr2D);
+
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      _mlir_ciface_corr_2d_replicate_padding(
+          &inputBuddyCorr2D, &kernelBuddyCorr2D, &outputBuddyCorr2D,
+          1 /* Center X */, 1 /* Center Y */, 0.0f /* Constant Value */);
+    }
+  }
+}
+
 // Register benchmarking function.
-BENCHMARK(Buddy_Corr2D)->Arg(1);
+void registerBenchmarkBuddyCorr2D() {
+  if (BoundaryType == replicate_padding) {
+    BENCHMARK(Buddy_Corr2D_Replicate_Padding)->Arg(1);
+  } else {
+    BENCHMARK(Buddy_Corr2D_Constant_Padding)->Arg(1);
+  }
+}
 
 // Generate result image.
 void generateResultBuddyCorr2D(char **argv) {
@@ -99,9 +141,15 @@ void generateResultBuddyCorr2D(char **argv) {
   MemRef<float, 2> kernel(get<0>(kernelMap[argv[2]]), sizesKernelBuddyCorr2D);
   MemRef<float, 2> output(sizesOutputBuddyCorr2D);
   // Run the 2D correlation.
-  _mlir_ciface_corr_2d_constant_padding(&input, &kernel, &output,
-                                        1 /* Center X */, 1 /* Center Y */,
-                                        0.0f /* Constant Value */);
+  if (static_cast<string>(argv[3]) == "REPLICATE_PADDING") {
+    _mlir_ciface_corr_2d_replicate_padding(&input, &kernel, &output,
+                                           1 /* Center X */, 1 /* Center Y */,
+                                           0.0f /* Constant Value */);
+  } else {
+    _mlir_ciface_corr_2d_constant_padding(&input, &kernel, &output,
+                                          1 /* Center X */, 1 /* Center Y */,
+                                          0.0f /* Constant Value */);
+  }
 
   // Define a cv::Mat with the output of the correlation.
   Mat outputImage(outputRowsBuddyCorr2D, outputColsBuddyCorr2D, CV_32FC1,

benchmarks/ImageProcessing/Main.cpp

@@ -32,17 +32,21 @@ void generateResultBuddyCorr2D(char **);
 void generateResultOpenCVFilter2D();
 void generateResultEigenConvolve2D();
 
+void registerBenchmarkBuddyCorr2D();
+void registerBenchmarkOpenCVFilter2D();
+
 // Run benchmarks.
 int main(int argc, char **argv) {
-  if (argc != 3 && argc != 5) {
+  if (argc != 4) {
     throw std::invalid_argument(
         "Wrong format of command line arguments.\n"
         "Correct format is ./image-processing-benchmark <image path> <kernel "
-        "name>\n where "
-        "image path provides path of the image to be processed and kernel name "
+        "name> <Boundary Option>\n where "
+        "image path provides path of the image to be processed, kernel name "
         "denotes the name "
         "of desired kernel as specified in "
-        "include/ImageProcessing/Kernels.h\n");
+        "include/ImageProcessing/Kernels.h and Boundary options available "
+        "are CONSTANT_PADDING, REPLICATE_PADDING.\n");
   }
 
   initializeMLIRConv2D(argv);
@@ -51,6 +55,9 @@ int main(int argc, char **argv) {
   initializeOpenCVFilter2D(argv);
   initializeEigenConvolve2D(argv);
 
+  registerBenchmarkBuddyCorr2D();
+  registerBenchmarkOpenCVFilter2D();
+
   ::benchmark::Initialize(&argc, argv);
   ::benchmark::RunSpecifiedBenchmarks();
 

benchmarks/ImageProcessing/OpenCVFilter2DBenchmark.cpp

@@ -28,15 +28,27 @@ using namespace std;
 // Declare input image, kernel and output image.
 Mat inputImageFilter2D, kernelFilter2D, outputFilter2D;
 
+// Declare Boundary Options supported.
+enum BoundaryOption { constant_padding, replicate_padding };
+
+// Define Boundary option selected.
+BoundaryOption OpenCVBoundaryType;
+
 void initializeOpenCVFilter2D(char **argv) {
   inputImageFilter2D = imread(argv[1], IMREAD_GRAYSCALE);
 
   kernelFilter2D = Mat(get<1>(kernelMap[argv[2]]), get<2>(kernelMap[argv[2]]),
                        CV_32FC1, get<0>(kernelMap[argv[2]]));
+
+  if (static_cast<string>(argv[3]) == "REPLICATE_PADDING") {
+    OpenCVBoundaryType = replicate_padding;
+  } else {
+    OpenCVBoundaryType = constant_padding;
+  }
 }
 
 // Benchmarking function.
-static void OpenCV_Filter2D(benchmark::State &state) {
+static void OpenCV_Filter2D_Constant_Padding(benchmark::State &state) {
   for (auto _ : state) {
     for (int i = 0; i < state.range(0); ++i) {
       filter2D(inputImageFilter2D, outputFilter2D, CV_32FC1, kernelFilter2D,
@@ -45,13 +57,33 @@ static void OpenCV_Filter2D(benchmark::State &state) {
   }
 }
 
+static void OpenCV_Filter2D_Replicate_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      filter2D(inputImageFilter2D, outputFilter2D, CV_32FC1, kernelFilter2D,
+               cv::Point(-1, -1), 0.0, cv::BORDER_REPLICATE);
+    }
+  }
+}
+
 // Register benchmarking function.
-BENCHMARK(OpenCV_Filter2D)->Arg(1);
+void registerBenchmarkOpenCVFilter2D() {
+  if (OpenCVBoundaryType == replicate_padding) {
+    BENCHMARK(OpenCV_Filter2D_Replicate_Padding)->Arg(1);
+  } else {
+    BENCHMARK(OpenCV_Filter2D_Constant_Padding)->Arg(1);
+  }
+}
 
 // Generate result image.
 void generateResultOpenCVFilter2D() {
-  filter2D(inputImageFilter2D, outputFilter2D, CV_32FC1, kernelFilter2D,
-               cv::Point(-1, -1), 0.0, cv::BORDER_CONSTANT);
+  if (OpenCVBoundaryType == replicate_padding) {
+    filter2D(inputImageFilter2D, outputFilter2D, CV_32FC1, kernelFilter2D,
+             cv::Point(-1, -1), 0.0, cv::BORDER_REPLICATE);
+  } else {
+    filter2D(inputImageFilter2D, outputFilter2D, CV_32FC1, kernelFilter2D,
+             cv::Point(-1, -1), 0.0, cv::BORDER_CONSTANT);
+  }
 
   // Choose a PNG compression level
   vector<int> compressionParams;
@@ -61,7 +93,8 @@ void generateResultOpenCVFilter2D() {
   // Write output to PNG.
   bool result = false;
   try {
-    result = imwrite("ResultOpenCVFilter2D.png", outputFilter2D, compressionParams);
+    result =
+        imwrite("ResultOpenCVFilter2D.png", outputFilter2D, compressionParams);
   } catch (const cv::Exception &ex) {
     fprintf(stderr, "Exception converting image to PNG format: %s\n",
             ex.what());