[DIP] Improve DIP benchmark.

README.md

@@ -27,6 +27,7 @@ Run the image processing benchmark:
 | CMake Options  | Default Value |
 | -------------- | ------------- |
 | `-DBUDDY_OPT_STRIP_MINING`  | 256  |
+| `-DMLIR_LINALG_TILE`  | 2  |
 | `-DBUDDY_OPT_ATTR`  | avx512f  |
 | `-DBUDDY_OPT_TRIPLE`  | x86_64-unknown-linux-gnu  |
 

benchmarks/ImageProcessing/BuddyConv2D.mlir

+//===- BuddyConv2D.mlir ---------------------------------------------------===//
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides the MLIR 2D convolution function.
+//
+//===----------------------------------------------------------------------===//
+
+func @buddy_conv_2d(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
+  linalg.conv_2d ins (%arg0, %arg1: memref<?x?xf32>, memref<?x?xf32>)
+                 outs (%arg2: memref<?x?xf32>)
+  return
+}

benchmarks/ImageProcessing/BuddyConv2DBenchmark.cpp

+//===- BuddyConv2DBenchmark.cpp -------------------------------------------===//
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the benchmark for buddy-opt tool in buddy-mlir project.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ImageProcessing/Kernels.h"
+#include "Utils/Container.h"
+#include <benchmark/benchmark.h>
+#include <opencv2/opencv.hpp>
+
+using namespace cv;
+using namespace std;
+
+// Declare the conv2d C interface.
+extern "C" {
+void _mlir_ciface_buddy_conv_2d(MemRef<float, 2> *inputBuddyConv2D,
+                                MemRef<float, 2> *kernelBuddyConv2D,
+                                MemRef<float, 2> *outputBuddyConv2D);
+}
+
+// Read input image.
+Mat inputImageBuddyConv2D, kernelBuddyConv2DMat;
+
+// Define the kernel size.
+int kernelRowsBuddyConv2D, kernelColsBuddyConv2D;
+
+// Define the output size.
+int outputRowsBuddyConv2D, outputColsBuddyConv2D;
+
+// Define sizes of input, kernel, and output.
+intptr_t sizesInputBuddyConv2D[2];
+intptr_t sizesKernelBuddyConv2D[2];
+intptr_t sizesOutputBuddyConv2D[2];
+
+void initializeBuddyConv2D(int argc, char **argv) {
+  inputImageBuddyConv2D = imread(argv[1], IMREAD_GRAYSCALE);
+  kernelBuddyConv2DMat =
+      Mat(get<1>(kernelMap[argv[2]]), get<2>(kernelMap[argv[2]]), CV_32FC1,
+          get<0>(kernelMap[argv[2]]));
+
+  kernelRowsBuddyConv2D = kernelBuddyConv2DMat.rows;
+  kernelColsBuddyConv2D = kernelBuddyConv2DMat.cols;
+
+  outputRowsBuddyConv2D =
+      inputImageBuddyConv2D.rows - kernelRowsBuddyConv2D + 1;
+  outputColsBuddyConv2D =
+      inputImageBuddyConv2D.cols - kernelColsBuddyConv2D + 1;
+
+  sizesInputBuddyConv2D[0] = inputImageBuddyConv2D.rows;
+  sizesInputBuddyConv2D[1] = inputImageBuddyConv2D.cols;
+
+  sizesKernelBuddyConv2D[0] = kernelRowsBuddyConv2D;
+  sizesKernelBuddyConv2D[1] = kernelColsBuddyConv2D;
+
+  sizesOutputBuddyConv2D[0] = outputRowsBuddyConv2D;
+  sizesOutputBuddyConv2D[1] = outputColsBuddyConv2D;
+}
+
+static void Buddy_Conv2D(benchmark::State &state) {
+  // Define the MemRef descriptor for input, kernel, and output.
+  MemRef<float, 2> inputBuddyConv2D(inputImageBuddyConv2D,
+                                    sizesInputBuddyConv2D);
+  MemRef<float, 2> kernelBuddyConv2D(kernelBuddyConv2DMat,
+                                     sizesKernelBuddyConv2D);
+  MemRef<float, 2> outputBuddyConv2D(sizesOutputBuddyConv2D);
+
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      _mlir_ciface_buddy_conv_2d(&inputBuddyConv2D, &kernelBuddyConv2D,
+                                 &outputBuddyConv2D);
+    }
+  }
+}
+
+// Register benchmarking function.
+BENCHMARK(Buddy_Conv2D)->Arg(1);
+
+// Generate result image.
+void generateResultBuddyConv2D() {
+  // Define the MemRef descriptor for input, kernel, and output.
+  MemRef<float, 2> input(inputImageBuddyConv2D, sizesInputBuddyConv2D);
+  MemRef<float, 2> kernel(kernelBuddyConv2DMat, sizesKernelBuddyConv2D);
+  MemRef<float, 2> output(sizesOutputBuddyConv2D);
+  // Run the 2D convolution.
+  _mlir_ciface_buddy_conv_2d(&input, &kernel, &output);
+
+  // Define a cv::Mat with the output of the convolution.
+  Mat outputImage(outputRowsBuddyConv2D, outputColsBuddyConv2D, CV_32FC1,
+                  output.getData());
+
+  // Choose a PNG compression level
+  vector<int> compressionParams;
+  compressionParams.push_back(IMWRITE_PNG_COMPRESSION);
+  compressionParams.push_back(9);
+
+  // Write output to PNG.
+  bool result = false;
+  try {
+    result = imwrite("ResultBuddyConv2D.png", outputImage, compressionParams);
+  } catch (const cv::Exception &ex) {
+    fprintf(stderr, "Exception converting image to PNG format: %s\n",
+            ex.what());
+  }
+  if (result)
+    cout << "Saved PNG file." << endl;
+  else
+    cout << "ERROR: Can't save PNG file." << endl;
+}

benchmarks/ImageProcessing/Corr2D.mlir → benchmarks/ImageProcessing/BuddyCorr2D.mlir

+//===- BuddyCorr2D.mlir ---------------------------------------------------===//
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides the Buddy Corr2D function.
+//
+//===----------------------------------------------------------------------===//
+
 func @corr_2d(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, 
               %outputImage : memref<?x?xf32>, %centerX : index, 
               %centerY : index, %boundaryOption : index) {
@@ -5,4 +25,4 @@ func @corr_2d(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>,
               %boundaryOption : memref<?x?xf32>, memref<?x?xf32>, 
                                 memref<?x?xf32>, index, index, index
   return
-}
\ No newline at end of file
+}

benchmarks/ImageProcessing/Corr2DBenchmark.cpp → benchmarks/ImageProcessing/BuddyCorr2DBenchmark.cpp

-//===- Corr2DBenchmark.cpp ------------------------------------------------===//
+//===- BuddyCorr2DBenchmark.cpp -------------------------------------------===//
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -28,77 +28,81 @@ using namespace std;
 
 // Declare the conv2d C interface.
 extern "C" {
-void _mlir_ciface_corr_2d(MemRef<float, 2> *inputCorr2D,
-                          MemRef<float, 2> *kernelCorr2D,
-                          MemRef<float, 2> *outputCorr2D, unsigned int centerX,
-                          unsigned int centerY, int boundaryOption);
+void _mlir_ciface_corr_2d(MemRef<float, 2> *inputBuddyCorr2D,
+                          MemRef<float, 2> *kernelBuddyCorr2D,
+                          MemRef<float, 2> *outputBuddyCorr2D,
+                          unsigned int centerX, unsigned int centerY,
+                          int boundaryOption);
 }
 
 // Declare input image and kernel.
-Mat inputImageCorr2D, kernelCorr2DMat;
+Mat inputImageBuddyCorr2D, kernelBuddyCorr2DMat;
 
 // Define the kernel size.
-int kernelRowsCorr2D, kernelColsCorr2D;
+int kernelRowsBuddyCorr2D, kernelColsBuddyCorr2D;
 
 // Define the output size.
-int outputRowsCorr2D, outputColsCorr2D;
+int outputRowsBuddyCorr2D, outputColsBuddyCorr2D;
 
 // Define sizes of input, kernel, and output.
-intptr_t sizesInputCorr2D[2];
-intptr_t sizesKernelCorr2D[2];
-intptr_t sizesOutputCorr2D[2];
+intptr_t sizesInputBuddyCorr2D[2];
+intptr_t sizesKernelBuddyCorr2D[2];
+intptr_t sizesOutputBuddyCorr2D[2];
 
-void initializeBM_Corr2D_Buddy(int argc, char **argv) {
-  inputImageCorr2D = imread(argv[1], IMREAD_GRAYSCALE);
-  kernelCorr2DMat = Mat(get<1>(kernelMap[argv[2]]), get<2>(kernelMap[argv[2]]),
-                        CV_32FC1, get<0>(kernelMap[argv[2]]));
+void initializeBuddyCorr2D(int argc, char **argv) {
+  inputImageBuddyCorr2D = imread(argv[1], IMREAD_GRAYSCALE);
+  kernelBuddyCorr2DMat =
+      Mat(get<1>(kernelMap[argv[2]]), get<2>(kernelMap[argv[2]]), CV_32FC1,
+          get<0>(kernelMap[argv[2]]));
 
-  kernelRowsCorr2D = kernelCorr2DMat.rows;
-  kernelColsCorr2D = kernelCorr2DMat.cols;
+  kernelRowsBuddyCorr2D = kernelBuddyCorr2DMat.rows;
+  kernelColsBuddyCorr2D = kernelBuddyCorr2DMat.cols;
 
-  outputRowsCorr2D = inputImageCorr2D.rows;
-  outputColsCorr2D = inputImageCorr2D.cols;
+  outputRowsBuddyCorr2D = inputImageBuddyCorr2D.rows;
+  outputColsBuddyCorr2D = inputImageBuddyCorr2D.cols;
 
-  sizesInputCorr2D[0] = inputImageCorr2D.rows;
-  sizesInputCorr2D[1] = inputImageCorr2D.cols;
+  sizesInputBuddyCorr2D[0] = inputImageBuddyCorr2D.rows;
+  sizesInputBuddyCorr2D[1] = inputImageBuddyCorr2D.cols;
 
-  sizesKernelCorr2D[0] = kernelRowsCorr2D;
-  sizesKernelCorr2D[1] = kernelColsCorr2D;
+  sizesKernelBuddyCorr2D[0] = kernelRowsBuddyCorr2D;
+  sizesKernelBuddyCorr2D[1] = kernelColsBuddyCorr2D;
 
-  sizesOutputCorr2D[0] = outputRowsCorr2D;
-  sizesOutputCorr2D[1] = outputColsCorr2D;
+  sizesOutputBuddyCorr2D[0] = outputRowsBuddyCorr2D;
+  sizesOutputBuddyCorr2D[1] = outputColsBuddyCorr2D;
 }
 
-static void BM_Corr2D_Buddy(benchmark::State &state) {
+static void Buddy_Corr2D(benchmark::State &state) {
   // Define the MemRef descriptor for input, kernel, and output.
-  MemRef<float, 2> inputCorr2D(inputImageCorr2D, sizesInputCorr2D);
-  MemRef<float, 2> kernelCorr2D(kernelCorr2DMat, sizesKernelCorr2D);
-  MemRef<float, 2> outputCorr2D(sizesOutputCorr2D);
+  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(&inputCorr2D, &kernelCorr2D, &outputCorr2D,
-                           1 /* Center X */, 1 /* Center Y */,
-                           0 /* Boundary Option */);
+      _mlir_ciface_corr_2d(&inputBuddyCorr2D, &kernelBuddyCorr2D,
+                           &outputBuddyCorr2D, 1 /* Center X */,
+                           1 /* Center Y */, 0 /* Boundary Option */);
     }
   }
 }
 
 // Register benchmarking function.
-BENCHMARK(BM_Corr2D_Buddy)->Arg(1);
+BENCHMARK(Buddy_Corr2D)->Arg(1);
 
 // Generate result image.
-void generateResultCorr2D() {
+void generateResultBuddyCorr2D() {
   // Define the MemRef descriptor for input, kernel, and output.
-  MemRef<float, 2> input(inputImageCorr2D, sizesInputCorr2D);
-  MemRef<float, 2> kernel(kernelCorr2DMat, sizesKernelCorr2D);
-  MemRef<float, 2> output(sizesOutputCorr2D);
+  MemRef<float, 2> input(inputImageBuddyCorr2D, sizesInputBuddyCorr2D);
+  MemRef<float, 2> kernel(kernelBuddyCorr2DMat, sizesKernelBuddyCorr2D);
+  MemRef<float, 2> output(sizesOutputBuddyCorr2D);
   // Run the 2D correlation.
   _mlir_ciface_corr_2d(&input, &kernel, &output, 1 /* Center X */,
                        1 /* Center Y */, 0 /* Boundary Option */);
 
   // Define a cv::Mat with the output of the correlation.
-  Mat outputImage(outputRowsCorr2D, outputColsCorr2D, CV_32FC1,
+  Mat outputImage(outputRowsBuddyCorr2D, outputColsBuddyCorr2D, CV_32FC1,
                   output.getData());
 
   // Choose a PNG compression level
@@ -109,7 +113,7 @@ void generateResultCorr2D() {
   // Write output to PNG.
   bool result = false;
   try {
-    result = imwrite("ResultCorr2D.png", outputImage, compressionParams);
+    result = imwrite("ResultBuddyCorr2D.png", outputImage, compressionParams);
   } catch (const cv::Exception &ex) {
     fprintf(stderr, "Exception converting image to PNG format: %s\n",
             ex.what());

benchmarks/ImageProcessing/CMakeLists.txt

 set(BUDDY_OPT_STRIP_MINING 256 CACHE STRING "Stride Size")
+set(MLIR_LINALG_TILE 2 CACHE STRING "MLIR Linalg Tile Size")
 set(LLVM_MLIR_BINARY_DIR ${BUDDY_OPT_BUILD_DIR}/../llvm/build/bin)
 
 message(STATUS "Configuring Stride Size: ${BUDDY_OPT_STRIP_MINING}")
+message(STATUS "Configuring MLIR Linalg Tile Size: ${MLIR_LINALG_TILE}")
 
 #-------------------------------------------------------------------------------
-# MLIR Linalg Dialect Conv2D Operation + CB Algorithm
+# MLIR Linalg Dialect Conv2D Operation + Upstream Lowering Passes
 #-------------------------------------------------------------------------------
 
-add_custom_command(OUTPUT conv2d.o
+add_custom_command(OUTPUT mlir-conv2d.o
+  COMMAND ${LLVM_MLIR_BINARY_DIR}/mlir-opt
+          ${BUDDY_SOURCE_DIR}/benchmarks/ImageProcessing/MLIRConv2D.mlir 
+            -linalg-tile="tile-sizes=${MLIR_LINALG_TILE},${MLIR_LINALG_TILE}"
+            -convert-linalg-to-loops
+            -convert-scf-to-std -convert-linalg-to-llvm
+            -lower-affine -convert-scf-to-std --convert-memref-to-llvm 
+            -convert-std-to-llvm='emit-c-wrappers=1'
+            -reconcile-unrealized-casts | 
+          ${LLVM_MLIR_BINARY_DIR}/mlir-translate --mlir-to-llvmir |
+          ${LLVM_MLIR_BINARY_DIR}/llc -mtriple=${BUDDY_OPT_TRIPLE} 
+            -mattr=${BUDDY_OPT_ATTR} --filetype=obj 
+            -o ${BUDDY_BINARY_DIR}/../benchmarks/ImageProcessing/mlir-conv2d.o
+)
+add_library(MLIRConv2D STATIC mlir-conv2d.o)
+set_target_properties(MLIRConv2D PROPERTIES LINKER_LANGUAGE CXX)
+
+#-------------------------------------------------------------------------------
+# MLIR Linalg Dialect Conv2D Operation + Buddy CB Algorithm
+#-------------------------------------------------------------------------------
+
+add_custom_command(OUTPUT buddy-conv2d.o
   COMMAND ${BUDDY_OPT_BUILD_DIR}/bin/buddy-opt
-          ${BUDDY_SOURCE_DIR}/benchmarks/ImageProcessing/Conv2D.mlir 
+          ${BUDDY_SOURCE_DIR}/benchmarks/ImageProcessing/BuddyConv2D.mlir 
             -conv-vectorization="strip-mining=${BUDDY_OPT_STRIP_MINING}" 
             -lower-affine -convert-scf-to-std -convert-vector-to-llvm 
             -convert-memref-to-llvm -convert-std-to-llvm='emit-c-wrappers=1' 
@@ -17,18 +40,18 @@ add_custom_command(OUTPUT conv2d.o
           ${LLVM_MLIR_BINARY_DIR}/mlir-translate --mlir-to-llvmir |
           ${LLVM_MLIR_BINARY_DIR}/llc -mtriple=${BUDDY_OPT_TRIPLE} 
             -mattr=${BUDDY_OPT_ATTR} --filetype=obj 
-            -o ${BUDDY_BINARY_DIR}/../benchmarks/ImageProcessing/conv2d.o
+            -o ${BUDDY_BINARY_DIR}/../benchmarks/ImageProcessing/buddy-conv2d.o
 )
-add_library(Conv2D STATIC conv2d.o)
-set_target_properties(Conv2D PROPERTIES LINKER_LANGUAGE CXX)
+add_library(BuddyConv2D STATIC buddy-conv2d.o)
+set_target_properties(BuddyConv2D PROPERTIES LINKER_LANGUAGE CXX)
 
 #-------------------------------------------------------------------------------
 # Buddy DIP Dialect Corr2D Operation + CB Algorithm
 #-------------------------------------------------------------------------------
 
-add_custom_command(OUTPUT corr2d.o
+add_custom_command(OUTPUT buddy-corr2d.o
   COMMAND ${BUDDY_OPT_BUILD_DIR}/bin/buddy-opt 
-          ${BUDDY_SOURCE_DIR}/benchmarks/ImageProcessing/Corr2D.mlir 
+          ${BUDDY_SOURCE_DIR}/benchmarks/ImageProcessing/BuddyCorr2D.mlir 
             -lower-dip="DIP-strip-mining=${BUDDY_OPT_STRIP_MINING}" 
             -lower-affine -convert-scf-to-std -convert-vector-to-llvm 
             -convert-memref-to-llvm -convert-std-to-llvm='emit-c-wrappers=1' 
@@ -36,10 +59,10 @@ add_custom_command(OUTPUT corr2d.o
           ${LLVM_MLIR_BINARY_DIR}/mlir-translate --mlir-to-llvmir |
           ${LLVM_MLIR_BINARY_DIR}/llc -mtriple=${BUDDY_OPT_TRIPLE} 
             -mattr=${BUDDY_OPT_ATTR} --filetype=obj 
-            -o ${BUDDY_BINARY_DIR}/../benchmarks/ImageProcessing/corr2d.o
+            -o ${BUDDY_BINARY_DIR}/../benchmarks/ImageProcessing/buddy-corr2d.o
 )
-add_library(Corr2D STATIC corr2d.o)
-set_target_properties(Corr2D PROPERTIES LINKER_LANGUAGE CXX)
+add_library(BuddyCorr2D STATIC buddy-corr2d.o)
+set_target_properties(BuddyCorr2D PROPERTIES LINKER_LANGUAGE CXX)
 
 #-------------------------------------------------------------------------------
 # Image Processing Benchmark Target
@@ -47,16 +70,18 @@ set_target_properties(Corr2D PROPERTIES LINKER_LANGUAGE CXX)
 
 add_executable(image-processing-benchmark
   Main.cpp 
-  Filter2DBenchmark.cpp
-  Conv2DBenchmark.cpp
-  Corr2DBenchmark.cpp
+  OpenCVFilter2DBenchmark.cpp
+  MLIRConv2DBenchmark.cpp
+  BuddyConv2DBenchmark.cpp
+  BuddyCorr2DBenchmark.cpp
   )
 
 target_link_libraries(image-processing-benchmark 
   GoogleBenchmark
   ${OpenCV_LIBS}
-  Conv2D
-  Corr2D
+  MLIRConv2D
+  BuddyConv2D
+  BuddyCorr2D
   Container
   PNGImage
   )

benchmarks/ImageProcessing/Conv2D.mlir → benchmarks/ImageProcessing/MLIRConv2D.mlir

-//===- Conv2D.mlir --------------------------------------------------------===//
+//===- MLIRConv2D.mlir ----------------------------------------------------===//
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -18,7 +18,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-func @conv_2d(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
+func @mlir_conv_2d(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
   linalg.conv_2d ins (%arg0, %arg1: memref<?x?xf32>, memref<?x?xf32>)
                  outs (%arg2: memref<?x?xf32>)
   return

benchmarks/ImageProcessing/Conv2DBenchmark.cpp → benchmarks/ImageProcessing/MLIRConv2DBenchmark.cpp

-//===- Conv2DBenchmark.cpp ------------------------------------------------===//
+//===- MLIRConv2DBenchmark.cpp --------------------------------------------===//
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -28,73 +28,75 @@ using namespace std;
 
 // Declare the conv2d C interface.
 extern "C" {
-void _mlir_ciface_conv_2d(MemRef<float, 2> *inputConv2D,
-                          MemRef<float, 2> *kernelConv2D,
-                          MemRef<float, 2> *outputConv2D);
+void _mlir_ciface_mlir_conv_2d(MemRef<float, 2> *inputConv2D,
+                               MemRef<float, 2> *kernelConv2D,
+                               MemRef<float, 2> *outputConv2D);
 }
 
 // Read input image.
-Mat inputImageConv2D, kernelConv2DMat;
+Mat inputImageMLIRConv2D, kernelMLIRConv2DMat;
 
 // Define the kernel size.
-int kernelRowsConv2D, kernelColsConv2D;
+int kernelRowsMLIRConv2D, kernelColsMLIRConv2D;
 
 // Define the output size.
-int outputRowsConv2D, outputColsConv2D;
+int outputRowsMLIRConv2D, outputColsMLIRConv2D;
 
 // Define sizes of input, kernel, and output.
-intptr_t sizesInputConv2D[2];
-intptr_t sizesKernelConv2D[2];
-intptr_t sizesOutputConv2D[2];
+intptr_t sizesInputMLIRConv2D[2];
+intptr_t sizesKernelMLIRConv2D[2];
+intptr_t sizesOutputMLIRConv2D[2];
 
-void initializeBM_Conv2D_Buddy(int argc, char **argv) {
-  inputImageConv2D = imread(argv[1], IMREAD_GRAYSCALE);
-  kernelConv2DMat = Mat(get<1>(kernelMap[argv[2]]), get<2>(kernelMap[argv[2]]),
-                        CV_32FC1, get<0>(kernelMap[argv[2]]));
+void initializeMLIRConv2D(int argc, char **argv) {
+  inputImageMLIRConv2D = imread(argv[1], IMREAD_GRAYSCALE);
+  kernelMLIRConv2DMat =
+      Mat(get<1>(kernelMap[argv[2]]), get<2>(kernelMap[argv[2]]), CV_32FC1,
+          get<0>(kernelMap[argv[2]]));
 
-  kernelRowsConv2D = kernelConv2DMat.rows;
-  kernelColsConv2D = kernelConv2DMat.cols;
+  kernelRowsMLIRConv2D = kernelMLIRConv2DMat.rows;
+  kernelColsMLIRConv2D = kernelMLIRConv2DMat.cols;
 
-  outputRowsConv2D = inputImageConv2D.rows - kernelRowsConv2D + 1;
-  outputColsConv2D = inputImageConv2D.cols - kernelColsConv2D + 1;
+  outputRowsMLIRConv2D = inputImageMLIRConv2D.rows - kernelRowsMLIRConv2D + 1;
+  outputColsMLIRConv2D = inputImageMLIRConv2D.cols - kernelColsMLIRConv2D + 1;
 
-  sizesInputConv2D[0] = inputImageConv2D.rows;
-  sizesInputConv2D[1] = inputImageConv2D.cols;
+  sizesInputMLIRConv2D[0] = inputImageMLIRConv2D.rows;
+  sizesInputMLIRConv2D[1] = inputImageMLIRConv2D.cols;
 
-  sizesKernelConv2D[0] = kernelRowsConv2D;
-  sizesKernelConv2D[1] = kernelColsConv2D;
+  sizesKernelMLIRConv2D[0] = kernelRowsMLIRConv2D;
+  sizesKernelMLIRConv2D[1] = kernelColsMLIRConv2D;
 
-  sizesOutputConv2D[0] = outputRowsConv2D;
-  sizesOutputConv2D[1] = outputColsConv2D;
+  sizesOutputMLIRConv2D[0] = outputRowsMLIRConv2D;
+  sizesOutputMLIRConv2D[1] = outputColsMLIRConv2D;
 }
 
-static void BM_Conv2D_Buddy(benchmark::State &state) {
+static void MLIR_Conv2D(benchmark::State &state) {
   // Define the MemRef descriptor for input, kernel, and output.
-  MemRef<float, 2> inputConv2D(inputImageConv2D, sizesInputConv2D);
-  MemRef<float, 2> kernelConv2D(kernelConv2DMat, sizesKernelConv2D);
-  MemRef<float, 2> outputConv2D(sizesOutputConv2D);
+  MemRef<float, 2> inputMLIRConv2D(inputImageMLIRConv2D, sizesInputMLIRConv2D);
+  MemRef<float, 2> kernelMLIRConv2D(kernelMLIRConv2DMat, sizesKernelMLIRConv2D);
+  MemRef<float, 2> outputMLIRConv2D(sizesOutputMLIRConv2D);
 
   for (auto _ : state) {
     for (int i = 0; i < state.range(0); ++i) {
-      _mlir_ciface_conv_2d(&inputConv2D, &kernelConv2D, &outputConv2D);
+      _mlir_ciface_mlir_conv_2d(&inputMLIRConv2D, &kernelMLIRConv2D,
+                                &outputMLIRConv2D);
     }
   }
 }
 
 // Register benchmarking function.
-BENCHMARK(BM_Conv2D_Buddy)->Arg(1);
+BENCHMARK(MLIR_Conv2D)->Arg(1);
 
 // Generate result image.
-void generateResultConv2D() {
+void generateResultMLIRConv2D() {
   // Define the MemRef descriptor for input, kernel, and output.
-  MemRef<float, 2> input(inputImageConv2D, sizesInputConv2D);
-  MemRef<float, 2> kernel(kernelConv2DMat, sizesKernelConv2D);
-  MemRef<float, 2> output(sizesOutputConv2D);
+  MemRef<float, 2> input(inputImageMLIRConv2D, sizesInputMLIRConv2D);
+  MemRef<float, 2> kernel(kernelMLIRConv2DMat, sizesKernelMLIRConv2D);
+  MemRef<float, 2> output(sizesOutputMLIRConv2D);
   // Run the 2D convolution.
-  _mlir_ciface_conv_2d(&input, &kernel, &output);
+  _mlir_ciface_mlir_conv_2d(&input, &kernel, &output);
 
   // Define a cv::Mat with the output of the convolution.
-  Mat outputImage(outputRowsConv2D, outputColsConv2D, CV_32FC1,
+  Mat outputImage(outputRowsMLIRConv2D, outputColsMLIRConv2D, CV_32FC1,
                   output.getData());
 
   // Choose a PNG compression level
@@ -105,7 +107,7 @@ void generateResultConv2D() {
   // Write output to PNG.
   bool result = false;
   try {
-    result = imwrite("ResultConv2D.png", outputImage, compressionParams);
+    result = imwrite("ResultMLIRConv2D.png", outputImage, compressionParams);
   } catch (const cv::Exception &ex) {
     fprintf(stderr, "Exception converting image to PNG format: %s\n",
             ex.what());

benchmarks/ImageProcessing/Main.cpp

@@ -20,12 +20,13 @@
 
 #include <benchmark/benchmark.h>
 
-void initializeBM_Conv2D_Buddy(int, char **);
-void initializeBM_Corr2D_Buddy(int, char **);
-void initializeBM_Filter2D_OpenCV(int, char **);
+void initializeMLIRConv2D(int, char **);
+void initializeBuddyConv2D(int, char **);
+void initializeBuddyCorr2D(int, char **);
+void initializeOpenCVFilter2D(int, char **);
 
-void generateResultConv2D();
-void generateResultCorr2D();
+void generateResultBuddyConv2D();
+void generateResultBuddyCorr2D();
 
 // Run benchmarks.
 int main(int argc, char **argv) {
@@ -40,15 +41,16 @@ int main(int argc, char **argv) {
         "include/ImageProcessing/Kernels.h\n");
   }
 
-  initializeBM_Conv2D_Buddy(argc, argv);
-  initializeBM_Corr2D_Buddy(argc, argv);
-  initializeBM_Filter2D_OpenCV(argc, argv);
+  initializeMLIRConv2D(argc, argv);
+  initializeBuddyConv2D(argc, argv);
+  initializeBuddyCorr2D(argc, argv);
+  initializeOpenCVFilter2D(argc, argv);
 
   ::benchmark::Initialize(&argc, argv);
   ::benchmark::RunSpecifiedBenchmarks();
   // Generate result image.
-  generateResultConv2D();
-  generateResultCorr2D();
+  generateResultBuddyConv2D();
+  generateResultBuddyCorr2D();
 
   return 0;
 }

benchmarks/ImageProcessing/Filter2DBenchmark.cpp → benchmarks/ImageProcessing/OpenCVFilter2DBenchmark.cpp

-//===- Filter2DBenchmark.cpp ----------------------------------------------===//
+//===- OpenCVFilter2DBenchmark.cpp ----------------------------------------===//
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -28,7 +28,7 @@ using namespace std;
 // Declare input image, kernel and output image.
 Mat inputImageFilter2D, kernelFilter2D, outputFilter2D;
 
-void initializeBM_Filter2D_OpenCV(int argc, char **argv) {
+void initializeOpenCVFilter2D(int argc, char **argv) {
   inputImageFilter2D = imread(argv[1], IMREAD_GRAYSCALE);
 
   kernelFilter2D = Mat(get<1>(kernelMap[argv[2]]), get<2>(kernelMap[argv[2]]),
@@ -36,7 +36,7 @@ void initializeBM_Filter2D_OpenCV(int argc, char **argv) {
 }
 
 // Benchmarking function.
-static void BM_Filter2D_OpenCV(benchmark::State &state) {
+static void OpenCV_Filter2D(benchmark::State &state) {
   for (auto _ : state) {
     for (int i = 0; i < state.range(0); ++i) {
       filter2D(inputImageFilter2D, outputFilter2D, CV_32FC1, kernelFilter2D,
@@ -46,4 +46,4 @@ static void BM_Filter2D_OpenCV(benchmark::State &state) {
 }
 
 // Register benchmarking function.
-BENCHMARK(BM_Filter2D_OpenCV)->Arg(1);
+BENCHMARK(OpenCV_Filter2D)->Arg(1);