Merge branch 'buddy-compiler:main' into compareImg_dev

Author: taiqzheng

README.md

@@ -97,7 +97,6 @@ $ mkdir build && cd build
 $ cmake -G Ninja .. \
     -DCMAKE_BUILD_TYPE=RELEASE \
     -DDEEP_LEARNING_BENCHMARKS=ON \
-    -DCMAKE_BUILD_TYPE=RELEASE \
     -DOpenCV_DIR=$PWD/../thirdparty/opencv/build/ \
     -DBUDDY_MLIR_BUILD_DIR=/PATH/TO/BUDDY-MLIR/BUILD/
 $ ninja
@@ -194,3 +193,27 @@ $ ninja vectorization-XXX-benchmark
 $ cd bin
 $ ./vectorization-XXX-benchmark
 ```
+## Gemmini Benchmark
+
+Currently, we use the Spike simulator to run the Gemmini cases.
+The cycle-accurate benchmark cases are working in the progress.
+Before building the benchmark target, please see the following table and ensure you use the correct configuration.
+
+| Cases | Hardware Configuration |
+| -------------- | ------------- |
+| Gemmini-ResNet-101  | defaultFpConfig ([link](./docs/GemminiConfig.md#using-default-float-point-configuration)) |
+
+We assume you have already built all the components in the Gemmini README file. Now, let's build and run the cases. 
+
+```
+$ source /path/to/chipyard/env.sh
+$ cd buddy-benchmark
+$ mkdir build && cd build
+$ cmake -G Ninja .. \
+    -DCMAKE_BUILD_TYPE=RELEASE \
+    -DBUDDY_MLIR_BUILD_DIR=/PATH/TO/BUDDY-MLIR/BUILD/ \
+    -DGEMMINI_BENCHMARKS=ON
+$ ninja
+$ cd bin
+$ spike --extension=gemmini pk Gemmini-ResNet-101
+```

benchmarks/CMakeLists.txt

@@ -18,3 +18,6 @@ if(OP_OPTIMIZATION_BENCHMARKS)
     add_subdirectory(OpOptimization)
 endif()
 
+if (GEMMINI_BENCHMARKS)
+    add_subdirectory(Gemmini)
+endif()

benchmarks/Gemmini/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(ResNet-101)

benchmarks/Gemmini/ResNet-101/.gitattributes

@@ -0,0 +1 @@
+ResNet101.mlir filter=lfs diff=lfs merge=lfs -text

benchmarks/Gemmini/ResNet-101/CMakeLists.txt

@@ -0,0 +1,61 @@
+set(RESNET101_TOSA_PIPELINE "builtin.module(func.func(tosa-to-linalg-named),func.func(tosa-to-tensor),func.func(tosa-to-linalg),func.func(tosa-to-arith))")
+set(BUDDY_MLIR_BINARY_DIR ${BUDDY_MLIR_BUILD_DIR}/bin)
+set(CMAKE_CXX_COMPILER riscv64-unknown-linux-gnu-g++)
+set(LLVM_MLIR_EXECUTION_ENGINE_DIR ${BUDDY_MLIR_BUILD_DIR}/../llvm/mlir/include/mlir/ExecutionEngine)
+set(GEMMINI_CONFIG "dim=4 acc_t=f32 elem_t=f32")
+
+if (NOT DEFINED ENV{RISCV})
+  message(FATAL_ERROR "Can't find RISCV environment variable(missing: RISCV_TOOLCHAIN)")
+endif()
+
+add_custom_command(
+OUTPUT 
+  resnet-101.o
+COMMAND 
+  ${BUDDY_MLIR_BINARY_DIR}/buddy-opt ${CMAKE_CURRENT_SOURCE_DIR}/ResNet101.mlir 
+  -pass-pipeline="${RESNET101_TOSA_PIPELINE}" | 
+  ${BUDDY_MLIR_BINARY_DIR}/buddy-opt 
+  -linalg-bufferize 
+  -convert-linalg-to-gemmini="acc_t=f32" 
+  -llvm-request-c-wrappers 
+  -empty-tensor-to-alloc-tensor 
+  -arith-bufferize 
+  -tensor-bufferize 
+  -func-bufferize   
+  -convert-linalg-to-loops  
+  -convert-vector-to-scf 
+  -linalg-bufferize 
+  -buffer-deallocation
+  -convert-vector-to-scf 
+  -convert-scf-to-cf 
+  -convert-vector-to-llvm 
+  -arith-expand 
+  -convert-math-to-llvm 
+  -convert-linalg-to-loops 
+  -expand-strided-metadata 
+  -lower-gemmini=${GEMMINI_CONFIG}
+  -reconcile-unrealized-casts |
+  ${BUDDY_MLIR_BINARY_DIR}/buddy-translate -buddy-to-llvmir |
+  ${BUDDY_MLIR_BINARY_DIR}/buddy-llc -filetype=obj -mtriple=riscv64 
+    -mattr=+buddyext,+D -float-abi=hard -o resnet-101.o
+)
+
+add_library(ResNet101 STATIC resnet-101.o)
+# TODO: Add cross-compiled CRunnerUtils library.
+add_library(CRunnerUtils STATIC CRunnerUtils.cpp)
+target_include_directories(CRunnerUtils
+  PRIVATE
+  ${LLVM_MLIR_EXECUTION_ENGINE_DIR}
+)
+set_target_properties(ResNet101 PROPERTIES LINKER_LANGUAGE CXX)
+add_executable(Gemmini-ResNet-101 Main.cpp)
+target_include_directories(Gemmini-ResNet-101
+  PRIVATE
+  images
+  include
+)
+target_link_libraries(Gemmini-ResNet-101
+  -static
+  ResNet101
+  CRunnerUtils
+)

benchmarks/Gemmini/ResNet-101/CRunnerUtils.cpp

@@ -0,0 +1,72 @@
+// The code here is from the upstream llvm, you can check
+// llvm/mlir/include/mlir/ExecutionEngine/CRunnerUtils.cpp
+
+#include <CRunnerUtils.h>
+#include <Msan.h>
+#include <cstdlib>
+#include <alloca.h>
+#include <sys/time.h>
+#include <malloc.h>
+#include <algorithm>
+#include <cinttypes>
+#include <cstdio>
+#include <cstdlib>
+#include <random>
+#include <string.h>
+
+extern "C" void memrefCopy(int64_t elemSize, UnrankedMemRefType<char> *srcArg,
+                           UnrankedMemRefType<char> *dstArg) {
+  DynamicMemRefType<char> src(*srcArg);
+  DynamicMemRefType<char> dst(*dstArg);
+
+  int64_t rank = src.rank;
+  MLIR_MSAN_MEMORY_IS_INITIALIZED(src.sizes, rank * sizeof(int64_t));
+
+  // Handle empty shapes -> nothing to copy.
+  for (int rankp = 0; rankp < rank; ++rankp)
+    if (src.sizes[rankp] == 0)
+      return;
+
+  char *srcPtr = src.data + src.offset * elemSize;
+  char *dstPtr = dst.data + dst.offset * elemSize;
+
+  if (rank == 0) {
+    memcpy(dstPtr, srcPtr, elemSize);
+    return;
+  }
+
+  int64_t *indices = static_cast<int64_t *>(alloca(sizeof(int64_t) * rank));
+  int64_t *srcStrides = static_cast<int64_t *>(alloca(sizeof(int64_t) * rank));
+  int64_t *dstStrides = static_cast<int64_t *>(alloca(sizeof(int64_t) * rank));
+
+  // Initialize index and scale strides.
+  for (int rankp = 0; rankp < rank; ++rankp) {
+    indices[rankp] = 0;
+    srcStrides[rankp] = src.strides[rankp] * elemSize;
+    dstStrides[rankp] = dst.strides[rankp] * elemSize;
+  }
+
+  int64_t readIndex = 0, writeIndex = 0;
+  for (;;) {
+    // Copy over the element, byte by byte.
+    memcpy(dstPtr + writeIndex, srcPtr + readIndex, elemSize);
+    // Advance index and read position.
+    for (int64_t axis = rank - 1; axis >= 0; --axis) {
+      // Advance at current axis.
+      auto newIndex = ++indices[axis];
+      readIndex += srcStrides[axis];
+      writeIndex += dstStrides[axis];
+      // If this is a valid index, we have our next index, so continue copying.
+      if (src.sizes[axis] != newIndex)
+        break;
+      // We reached the end of this axis. If this is axis 0, we are done.
+      if (axis == 0)
+        return;
+      // Else, reset to 0 and undo the advancement of the linear index that
+      // this axis had. Then continue with the axis one outer.
+      indices[axis] = 0;
+      readIndex -= src.sizes[axis] * srcStrides[axis];
+      writeIndex -= dst.sizes[axis] * dstStrides[axis];
+    }
+  }
+}

benchmarks/Gemmini/ResNet-101/Main.cpp

@@ -0,0 +1,74 @@
+//===- Main.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 is the main file of the Gemmini ResNet-101 benchmark.
+//
+//===----------------------------------------------------------------------===//
+
+#include <Cat.h>
+#include <Labels.h>
+#include <buddy/Core/Container.h>
+#include <iostream>
+#include <math.h>
+
+extern "C" {
+void _mlir_ciface_resnet101(MemRef<float, 2> *output, MemRef<float, 4> *input);
+}
+
+void softmax(float *input, size_t size) {
+  assert(0 <= size <= sizeof(input) / sizeof(float));
+  int i;
+  float m, sum, constant;
+  m = -INFINITY;
+  for (i = 0; i < size; ++i) {
+    if (m < input[i]) {
+      m = input[i];
+    }
+  }
+
+  sum = 0.0;
+  for (i = 0; i < size; ++i) {
+    sum += exp(input[i] - m);
+  }
+
+  constant = m + log(sum);
+  for (i = 0; i < size; ++i) {
+    input[i] = exp(input[i] - constant);
+  }
+}
+
+int main() {
+  intptr_t sizesInput[4] = {1, 299, 299, 3};
+  intptr_t sizesOutput[2] = {1, 1001};
+  MemRef<float, 4> input(catImg, sizesInput);
+  MemRef<float, 2> output(sizesOutput);
+  _mlir_ciface_resnet101(&output, &input);
+  float *out = output.getData();
+  softmax(out, 1001);
+  float maxVal = 0;
+  int maxIdx = 0;
+  for (int i = 0; i < 1001; ++i) {
+    if (out[i] > maxVal) {
+      maxVal = out[i];
+      maxIdx = i;
+    }
+  }
+  std::cout << "Classification Index: " << maxIdx << std::endl;
+  std::cout << "Classification: " << labels[maxIdx] << std::endl;
+  std::cout << "Probability: " << maxVal << std::endl;
+
+  return 0;
+}

benchmarks/Gemmini/ResNet-101/ResNet101.mlir

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed6c59a9ec272f921b8e4c5112d772163ae48865a4e658f42aeb19c2f5a79c36
+size 356793476