CMakeLists.txt

cmake_minimum_required(VERSION 3.18 FATAL_ERROR)
project(mmperf C CXX)

if(NOT "${CMAKE_CXX_STANDARD}")
  set(CMAKE_CXX_STANDARD 17)
endif()

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake/")
if(NOT DEFINED ${MMPERF_SOURCE})
  set(MMPERF_SOURCE ${CMAKE_CURRENT_SOURCE_DIR})
endif()
include(common)

include(ExternalProject)

if(NOT DEFINED MLIR_SOURCE)
  set(MLIR_SOURCE ${MMPERF_SOURCE}/external/llvm-project/llvm)
endif()
if(NOT DEFINED MLIR_BUILD)
  set(MLIR_BUILD ${CMAKE_BINARY_DIR}/mlir)
endif()
set(RUY_SOURCE ${MMPERF_SOURCE}/external/ruy)

set(EXTERNAL_PROJECT_COMMON_ARGS
  BUILD_ALWAYS TRUE
  USES_TERMINAL_CONFIGURE TRUE
  USES_TERMINAL_BUILD TRUE
  USES_TERMINAL_INSTALL TRUE
)

set(EXTERNAL_PROJECT_COMMON_CMAKE_ARGS
  -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
  -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
  -DCMAKE_EXE_LINKER_FLAGS_INIT=${CMAKE_EXE_LINKER_FLAGS_INIT}
  -DCMAKE_MODULE_LINKER_FLAGS_INIT=${CMAKE_MODULE_LINKER_FLAGS_INIT}
  -DCMAKE_SHARED_LINKER_FLAGS_INIT=${CMAKE_SHARED_LINKER_FLAGS_INIT}
)

# Build cpuinfo
set(CPUINFO_SOURCE ${MMPERF_SOURCE}/external/cpuinfo)
set(CPUINFO_BUILD_BENCHMARKS OFF)
set(CPUINFO_BUILD_MOCK_TESTS OFF)
set(CPUINFO_BUILD_UNIT_TESTS OFF)
set(CPUINFO_INSTALL ${CMAKE_BINARY_DIR}/cpuinfo-install)
ExternalProject_Add(cpuinfo
  PREFIX ${CMAKE_BINARY_DIR}/cpuinfo
  SOURCE_DIR ${CPUINFO_SOURCE}
  BINARY_DIR ${CPUINFO_BUILD}
  INSTALL_DIR ${CPUINFO_INSTALL}
  CMAKE_ARGS
    ${EXTERNAL_PROJECT_COMMON_CMAKE_ARGS}
    -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
    -DCMAKE_BUILD_TYPE:STRING=Release
    -DCPUINFO_BUILD_BENCHMARKS=OFF
    -DCPUINFO_BUILD_MOCK_TESTS=OFF
    -DCPUINFO_BUILD_UNIT_TESTS=OFF
  ${EXTERNAL_PROJECT_COMMON_ARGS}
)

# Build flatbuffers
set(FLATBUFFERS_SOURCE ${MMPERF_SOURCE}/external/flatbuffers)
set(FLATBUFFERS_INSTALL ${CMAKE_BINARY_DIR}/flatbuffers-install)
ExternalProject_Add(flatbuffers
  PREFIX ${CMAKE_BINARY_DIR}/flatbuffers
  SOURCE_DIR ${FLATBUFFERS_SOURCE}
  BINARY_DIR ${FLATBUFFERS_BUILD}
  INSTALL_DIR ${FLATBUFFERS_INSTALL}
  CMAKE_ARGS
    ${EXTERNAL_PROJECT_COMMON_CMAKE_ARGS}
    -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
    -DCMAKE_BUILD_TYPE:STRING=Release
  ${EXTERNAL_PROJECT_COMMON_ARGS}
)
set(MATMUL_DEPS flatbuffers)

# Build benchmarks
set(BENCHMARK_SOURCE ${MMPERF_SOURCE}/external/benchmark)
set(BENCHMARK_INSTALL ${CMAKE_BINARY_DIR}/benchmark-install)
ExternalProject_Add(benchmark
  PREFIX ${CMAKE_BINARY_DIR}/benchmark
  SOURCE_DIR ${BENCHMARK_SOURCE}
  BINARY_DIR ${BENCHMARK_BUILD}
  INSTALL_DIR ${BENCHMARK_INSTALL}
  CMAKE_ARGS
    ${EXTERNAL_PROJECT_COMMON_CMAKE_ARGS}
    -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
    -DCMAKE_BUILD_TYPE:STRING=Release
    -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
  ${EXTERNAL_PROJECT_COMMON_ARGS}
)
list(APPEND MATMUL_DEPS benchmark)

# Build MLIR
if(${USE_MLIR} OR ${USE_MLIR_CUDA} OR ${USE_IREE_LLVM_SANDBOX})
  find_package(Git REQUIRED)
  set(MLIR_INSTALL ${CMAKE_BINARY_DIR}/mlir-install)
  set(MLIR_LIB ${MLIR_INSTALL}/cmake/lib/mlir)

  set(MLIR_ENABLE_CUDA_RUNNER OFF)
  set(MLIR_ENABLE_BINDINGS_PYTHON OFF)
  set(LLVM_EXTERNAL_PROJECTS "")
  set(LLVM_SANDBOX_DIR ${MMPERF_SOURCE}/external/iree-llvm-sandbox)
  if(${USE_MLIR_CUDA})
    set(MLIR_ENABLE_CUDA_RUNNER ON)
  endif()

  if(${USE_IREE_LLVM_SANDBOX})
    set(MLIR_ENABLE_BINDINGS_PYTHON ON)
    set(LLVM_EXTERNAL_PROJECTS iree_llvm_sandbox)
  endif()

  ExternalProject_Add(mlir
    PREFIX ${CMAKE_BINARY_DIR}/mlir
    SOURCE_DIR ${MLIR_SOURCE}
    BINARY_DIR ${MLIR_BUILD}
    INSTALL_DIR ${MLIR_INSTALL}
    CMAKE_ARGS
      ${EXTERNAL_PROJECT_COMMON_CMAKE_ARGS}
      -DCMAKE_CUDA_COMPILER=${CMAKE_CUDA_COMPILER}
      -DLLVM_BUILD_LLVM_DYLIB:BOOL=OFF
      -DLLVM_LINK_LLVM_DYLIB:BOOL=OFF
      -DLLVM_INSTALL_UTILS:BOOL=ON
      -DLLVM_TARGETS_TO_BUILD:STRING=X86$<SEMICOLON>AArch64$<SEMICOLON>NVPTX$<SEMICOLON>AMDGPU
      -DLLVM_ENABLE_PROJECTS:STRING=mlir
      -DLLVM_INCLUDE_TOOLS:BOOL=ON
      -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
      -DCMAKE_BUILD_TYPE:STRING=Release
      -DLLVM_ENABLE_ASSERTIONS:BOOL=ON
      -DLLVM_ENABLE_RTTI:BOOL=ON
      -DMLIR_ENABLE_CUDA_RUNNER:BOOL=${MLIR_ENABLE_CUDA_RUNNER}
      -DLLVM_EXTERNAL_PROJECTS=${LLVM_EXTERNAL_PROJECTS}
      -DLLVM_EXTERNAL_IREE_LLVM_SANDBOX_SOURCE_DIR=${LLVM_SANDBOX_DIR}
      -DMLIR_ENABLE_BINDINGS_PYTHON=${MLIR_ENABLE_BINDINGS_PYTHON}
      -DPython3_EXECUTABLE=$(which python3)
    ${EXTERNAL_PROJECT_COMMON_ARGS}
  )
  list(APPEND MATMUL_DEPS mlir)
endif()

# Build Halide
if(${USE_HALIDE})
  find_package(LLVM REQUIRED)
  set(HALIDE_SOURCE ${MMPERF_SOURCE}/external/Halide)
  set(HALIDE_BUILD ${CMAKE_BINARY_DIR}/halide)
  set(HALIDE_INSTALL ${CMAKE_BINARY_DIR}/halide-install)
  ExternalProject_Add(halide
    PREFIX ${CMAKE_BINARY_DIR}/halide
    SOURCE_DIR ${HALIDE_SOURCE}
    BINARY_DIR ${HALIDE_BUILD}
    INSTALL_DIR ${HALIDE_INSTALL}
    CMAKE_ARGS
      ${EXTERNAL_PROJECT_COMMON_CMAKE_ARGS}
      -DCMAKE_BUILD_TYPE:STRING=Release
      -DTARGET_WEBASSEMBLY:BOOL=OFF
      -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
      -DWITH_PYTHON_BINDINGS=OFF
    ${EXTERNAL_PROJECT_COMMON_ARGS}
  )
  list(APPEND MATMUL_DEPS halide)
endif()

# Build TVM
if(${USE_TVM} OR ${USE_TVM_CUDA})
  set(TVM_SOURCE ${MMPERF_SOURCE}/external/tvm)
  set(TVM_BUILD ${CMAKE_BINARY_DIR}/tvm)
  set(TVM_INSTALL ${CMAKE_BINARY_DIR}/tvm-install)
  option(TVM_ENABLE_CUDA "Enable CUDA in TVM" OFF)
  option(TVM_ENABLE_ROCM "Enable ROCM in TVM" OFF)
  option(TVM_ENABLE_METAL "Enable METAL in TVM" OFF)
  ExternalProject_Add(tvm
    PREFIX ${CMAKE_BINARY_DIR}/tvm
    SOURCE_DIR ${TVM_SOURCE}
    BINARY_DIR ${TVM_BUILD}
    INSTALL_DIR ${TVM_INSTALL}
    CMAKE_ARGS
      ${EXTERNAL_PROJECT_COMMON_CMAKE_ARGS}
      -DUSE_CUDA=${TVM_ENABLE_CUDA}
      -DUSE_ROCM=${TVM_ENABLE_ROCM}
      -DUSE_METAL=${TVM_ENABLE_METAL}
      -DUSE_RPC:BOOL=ON
      -DUSE_THREADS:BOOL=ON
      -DUSE_LLVM:BOOL=ON
      -DCMAKE_BUILD_TYPE:STRING=Release
      -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
    ${EXTERNAL_PROJECT_COMMON_ARGS}
  )
  list(APPEND MATMUL_DEPS tvm)
endif()

set(MATMUL_CMAKE_ARGS "")
foreach(var IN LISTS VARS_TO_COPY)
  list(APPEND MATMUL_CMAKE_ARGS -D${var}=${${var}})
endforeach()

# Build matmul-iree
if(${USE_IREE} STREQUAL "ON")
  set(IREE_SOURCE ${MMPERF_SOURCE}/external/iree)
  
  set(IREE_TARGET_BACKEND_CUDA OFF)
  set(IREE_HAL_DRIVER_CUDA OFF)
  if(${IREE_CUDA})
    set(IREE_TARGET_BACKEND_CUDA ON)
    set(IREE_HAL_DRIVER_CUDA ON)
  endif()

  ExternalProject_Add(matmul-iree
    DEPENDS
      benchmark
      flatbuffers
    PREFIX ${CMAKE_BINARY_DIR}/matmul-iree
    SOURCE_DIR ${MMPERF_SOURCE}/matmul-iree
    BINARY_DIR ${CMAKE_BINARY_DIR}/matmul-iree
    INSTALL_COMMAND ${CMAKE_COMMAND} -E echo "Skipping install step."
    CMAKE_ARGS
      ${EXTERNAL_PROJECT_COMMON_CMAKE_ARGS}
      -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=ON
      -DIREE_SOURCE=${IREE_SOURCE}
      -DIREE_TARGET_BACKEND_CUDA:BOOL=${IREE_TARGET_BACKEND_CUDA}
      -DIREE_HAL_DRIVER_CUDA:BOOL=${IREE_HAL_DRIVER_CUDA}
      ${MATMUL_CMAKE_ARGS}
    ${EXTERNAL_PROJECT_COMMON_ARGS}
  )
endif()

# Build matmul for compiling and running various compiled matmuls
ExternalProject_Add(matmul
  DEPENDS ${MATMUL_DEPS}
  PREFIX ${CMAKE_BINARY_DIR}/matmul
  SOURCE_DIR ${MMPERF_SOURCE}/matmul
  BINARY_DIR ${CMAKE_BINARY_DIR}/matmul
  INSTALL_COMMAND ${CMAKE_COMMAND} -E echo "Skipping install step."
  CMAKE_ARGS
    ${EXTERNAL_PROJECT_COMMON_CMAKE_ARGS}
    -DPREBUILT_LLVM_PATH=${PREBUILT_LLVM_PATH}  # switch if want to compile with a prebuilt llvm
    -DMLIR_DIR=${MLIR_INSTALL}/lib/cmake/mlir
    -DMLIR_BUILD=${MLIR_BUILD}
    -DCMAKE_BUILD_TYPE:STRING=RelWithDebInfo
    -DMKL_DIR=${MKL_DIR}
    -DHALIDE_DIR=${HALIDE_INSTALL}
    -DBLASFEO_DIR=${BLASFEO_DIR}
    -DBLIS_DIR=${BLIS_DIR}
    -DRUY_SOURCE=${RUY_SOURCE}
    -DTVM_LIB_DIR=${TVM_LIB_DIR}
    -DTVM_ENABLE_CUDA=${TVM_ENABLE_CUDA}
    -DTVM_ENABLE_ROCM=${TVM_ENABLE_ROCM}
    -DTVM_ENABLE_METAL=${TVM_ENABLE_METAL}
    -DSANDBOX_TILE_FILE=${SANDBOX_TILE_FILE}
    ${MATMUL_CMAKE_ARGS}
  ${EXTERNAL_PROJECT_COMMON_ARGS}
)