[BUILD] Switch to CMake only Infra

.gitignore

@@ -172,16 +172,19 @@ cscope*
 
 # TVM generated code
 perf
-
+.bash_history
 *.json
 *.params
 *.onnx
 *.h5
 synset.txt
 cat.jpg
-
+docs.tgz
+cat.png
+*.mlmodel
 # Mac OS X
 .DS_Store
+build*
 
 # Jetbrain
 .idea

CMakeLists.txt

@@ -1,12 +1,14 @@
-cmake_minimum_required(VERSION 3.7)
+cmake_minimum_required(VERSION 3.5)
 project(tvm C CXX)
 
+# Utility functions
+include(cmake/util/Util.cmake)
+include(cmake/util/FindLLVM.cmake)
+
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/build/private/local_config.cmake)
   include(${CMAKE_CURRENT_SOURCE_DIR}/build/private/local_config.cmake)
 endif()
 
-include(cmake/Util.cmake)
-
 if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/config.cmake)
   include(${CMAKE_CURRENT_BINARY_DIR}/config.cmake)
 else()
@@ -19,31 +21,43 @@ endif()
 # You can create a config.cmake at build folder
 # and add set(OPTION VALUE) to override these build options.
 # Alernatively, use cmake -DOPTION=VALUE through command-line.
-
 tvm_option(USE_CUDA "Build with CUDA" OFF)
 tvm_option(USE_OPENCL "Build with OpenCL" OFF)
 tvm_option(USE_VULKAN "Build with Vulkan" OFF)
 tvm_option(USE_OPENGL "Build with OpenGL" OFF)
 tvm_option(USE_METAL "Build with Metal" OFF)
+tvm_option(USE_ROCM "Build with ROCM" OFF)
+tvm_option(ROCM_PATH "The path to rocm" /opt/rocm)
 tvm_option(USE_RPC "Build with RPC" ON)
+tvm_option(USE_LLVM "Build with LLVM, can be set to specific llvm-config path" OFF)
 tvm_option(USE_GRAPH_RUNTIME "Build with tiny graph runtime" ON)
-tvm_option(USE_LLVM "Build with LLVM" OFF)
+tvm_option(USE_GRAPH_RUNTIME_DEBUG "Build with tiny graph runtime debug mode" OFF)
 tvm_option(USE_RTTI "Build with RTTI" ON)
 tvm_option(USE_MSVC_MT "Build with MT" OFF)
 tvm_option(INSTALL_DEV "Install compiler infrastructure" OFF)
 
+# Contrib library options
+tvm_option(USE_BLAS "The blas library to be linked" none)
 tvm_option(USE_CUDNN "Build with cuDNN" OFF)
-
+tvm_option(USE_CUBLAS "Build with cuBLAS" OFF)
+tvm_option(USE_MIOPEN "Build with ROCM:MIOpen" OFF)
+tvm_option(USE_ROCBLAS "Build with ROCM:RoCBLAS" OFF)
+tvm_option(USE_SORT "Build with sort support" OFF)
+tvm_option(USE_NNPACK "Build with nnpack support" OFF)
+tvm_option(USE_RANDOM "Build with random support" OFF)
+
+# include directories
 include_directories(BEFORE "nnvm/include")
 include_directories("include")
 include_directories("HalideIR/src")
 include_directories("dlpack/include")
+include_directories("topi/include")
 
-
+# initial variables
 set(TVM_LINKER_LIBS "")
 set(TVM_RUNTIME_LINKER_LIBS "")
 
-# compile
+# Generic compilation options
 if(MSVC)
   add_definitions(-DWIN32_LEAN_AND_MEAN)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
@@ -70,11 +84,12 @@ endif(MSVC)
 
 # add source group
 FILE(GLOB_RECURSE GROUP_SOURCE "src/*.cc" "HalideIR/src/*.cpp" "nnvm/src/*.cc")
-FILE(GLOB_RECURSE GROUP_Include "src/*.h" "include/*.h" "HalideIR/src/*.h"
+FILE(GLOB_RECURSE GROUP_INCLUDE "src/*.h" "include/*.h" "HalideIR/src/*.h"
                                 "nnvm/src/*.h" "nnvm/include/*.h")
 assign_source_group("Source" ${GROUP_SOURCE})
-assign_source_group("Include" ${GROUP_Include})
+assign_source_group("Include" ${GROUP_INCLUDE})
 
+# Source file lists
 file(GLOB COMPILER_SRCS
     src/api/*.cc
     src/arithmetic/*.cc
@@ -86,6 +101,11 @@ file(GLOB COMPILER_SRCS
     src/schedule/*.cc
     )
 
+if(NOT MSVC)
+  file(GLOB COMPILER_VERILOG_SRCS src/codegen/verilog/*.cc)
+  list(APPEND COMPILER_SRCS ${COMPILER_VERILOG_SRCS})
+endif()
+
 file(GLOB_RECURSE NNVM_COMPILER_SRCS
     nnvm/src/c_api/*.cc
     nnvm/src/core/*.cc
@@ -94,157 +114,34 @@ file(GLOB_RECURSE NNVM_COMPILER_SRCS
     nnvm/src/top/*.cc
     )
 
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/topi/include)
 file(GLOB TOPI_SRCS
     topi/src/*.cc
 )
 file(GLOB_RECURSE HALIDEIR_SRCS HalideIR/src/*.cpp)
 list(APPEND COMPILER_SRCS ${HALIDEIR_SRCS})
 file(GLOB RUNTIME_SRCS src/runtime/*.cc)
-file(GLOB COMPILER_LLVM_SRCS src/codegen/llvm/*.cc)
-file(GLOB COMPILER_VULKAN_SRCS src/codegen/spirv/*.cc)
-file(GLOB RUNTIME_CUDA_SRCS src/runtime/cuda/*.cc)
-file(GLOB RUNTIME_OPENCL_SRCS src/runtime/opencl/*.cc)
-file(GLOB RUNTIME_OPENGL_SRCS src/runtime/opengl/*.cc)
-file(GLOB RUNTIME_VULKAN_SRCS src/runtime/vulkan/*.cc)
-file(GLOB RUNTIME_METAL_SRCS src/runtime/metal/*.mm)
-file(GLOB RUNTIME_RPC_SRCS src/runtime/rpc/*.cc)
-file(GLOB RUNTIME_GRAPH_SRCS src/runtime/graph/*.cc)
-
-if(USE_CUDA)
-find_package(CUDA)
-# Find CUDA doesn't find all the libraries we need, add the extra ones
-find_library(CUDA_CUDA_LIBRARIES cuda
-  PATHS ${CUDA_TOOLKIT_ROOT_DIR}
-  PATH_SUFFIXES lib lib64 targets/x86_64-linux/lib targets/x86_64-linux/lib/stubs)
-find_library(CUDA_NVRTC_LIBRARIES nvrtc
-  PATHS ${CUDA_TOOLKIT_ROOT_DIR}
-  PATH_SUFFIXES lib lib64 targets/x86_64-linux/lib targets/x86_64-linux/lib/stubs)
-  set(CUDA_CUDA_LIBRARY ${CUDA_CUDA_LIBRARIES})
 
-  find_package(CUDA QUIET REQUIRED)
-  message(STATUS "Build with CUDA support")
-	include_directories(${CUDA_INCLUDE_DIRS})
-  list(APPEND TVM_RUNTIME_LINKER_LIBS ${CUDA_CUDART_LIBRARY})
-  list(APPEND TVM_RUNTIME_LINKER_LIBS ${CUDA_CUDA_LIBRARY})
-  list(APPEND RUNTIME_SRCS ${RUNTIME_CUDA_SRCS})
-  if(MSVC)
-    find_library(CUDA_NVRTC_LIB nvrtc
-      ${CUDA_TOOLKIT_ROOT_DIR}/lib/x64
-      ${CUDA_TOOLKIT_ROOT_DIR}/lib/win32)
-    list(APPEND TVM_LINKER_LIBS ${CUDA_NVRTC_LIB})
-  else(MSVC)
-    find_library(CUDA_NVRTC_LIB nvrtc
-      ${CUDA_TOOLKIT_ROOT_DIR}/lib64
-      ${CUDA_TOOLKIT_ROOT_DIR}/lib)
-    list(APPEND TVM_LINKER_LIBS ${CUDA_NVRTC_LIB})
-  endif(MSVC)
-
-  if(USE_CUDNN)
-    message(STATUS "Build with cuDNN support")
-    file(GLOB CONTRIB_CUDNN_SRCS src/contrib/cudnn/*.cc)
-    list(APPEND RUNTIME_SRCS ${CONTRIB_CUDNN_SRCS})
-    if(MSVC)
-      find_library(CUDA_CUDNN_LIB cudnn
-        ${CUDA_TOOLKIT_ROOT_DIR}/lib/x64
-        ${CUDA_TOOLKIT_ROOT_DIR}/lib/win32)
-      list(APPEND TVM_RUNTIME_LINKER_LIBS ${CUDA_CUDNN_LIB})
-    else(MSVC)
-      find_library(CUDA_CUDNN_LIB cudnn
-        ${CUDA_TOOLKIT_ROOT_DIR}/lib64
-        ${CUDA_TOOLKIT_ROOT_DIR}/lib)
-      list(APPEND TVM_RUNTIME_LINKER_LIBS ${CUDA_CUDNN_LIB})
-    endif(MSVC)
-  endif(USE_CUDNN)
-
-  add_definitions(-DTVM_CUDA_RUNTIME=1)
-else(USE_CUDA)
-  add_definitions(-DTVM_CUDA_RUNTIME=0)
-endif(USE_CUDA)
-
-if(USE_OPENCL)
-  find_package(OpenCL QUIET REQUIRED)
-  message(STATUS "Build with OpenCL support")
-  include_directories(${OpenCL_INCLUDE_DIRS})
-  list(APPEND TVM_RUNTIME_LINKER_LIBS ${OpenCL_LIBRARIES})
-  list(APPEND RUNTIME_SRCS ${RUNTIME_OPENCL_SRCS})
-  add_definitions(-DTVM_OPENCL_RUNTIME=1)
-else(USE_OPENCL)
-  add_definitions(-DTVM_OPENCL_RUNTIME=0)
-endif(USE_OPENCL)
-
-if(USE_OPENGL)
-  find_package(OpenGL QUIET REQUIRED)
-  find_package(glfw3 QUIET REQUIRED)
-  message(STATUS "Build with OpenGL support")
-  include_directories(${OPENGL_INCLUDE_DIRS})
-  list(APPEND TVM_RUNTIME_LINKER_LIBS ${OpenGL_LIBRARIES} glfw)
-  list(APPEND RUNTIME_SRCS ${RUNTIME_OPENGL_SRCS})
-  add_definitions(-DTVM_OPENGL_RUNTIME=1)
-else(USE_OPENGL)
-  add_definitions(-DTVM_OPENGL_RUNTIME=0)
-endif(USE_OPENGL)
-
-if(USE_VULKAN)
-  find_package(Vulkan REQUIRED)
-  message(STATUS "Build with VULKAN support")
-  include_directories(${Vulkan_INCLUDE_DIRS})
-  list(APPEND TVM_RUNTIME_LINKER_LIBS ${Vulkan_LIBRARIES})
-  list(APPEND RUNTIME_SRCS ${RUNTIME_VULKAN_SRCS})
-  list(APPEND COMPILER_SRCS ${COMPILER_VULKAN_SRCS})
-  get_filename_component(VULKAN_LIB_PATH ${Vulkan_LIBRARY} DIRECTORY)
-  find_library(SPIRV_TOOLS_LIB SPIRV-Tools
-               ${VULKAN_LIB_PATH}/spirv-tools)
-  list(APPEND TVM_LINKER_LIBS ${SPIRV_TOOLS_LIB})
-  add_definitions(-DTVM_VULKAN_RUNTIME=1)
-else(USE_VULKAN)
-  add_definitions(-DTVM_VULKAN_RUNTIME=0)
-endif(USE_VULKAN)
-
-if(USE_METAL)
-  find_package(OpenCL QUIET REQUIRED)
-  message(STATUS "Build with Metal support")
-  FIND_LIBRARY(METAL_LIB Metal)
-  FIND_LIBRARY(FOUNDATION_LIB Foundation)
-  list(APPEND TVM_RUNTIME_LINKER_LIBS ${METAL_LIB} ${FOUNDATION_LIB})
-  list(APPEND RUNTIME_SRCS ${RUNTIME_METAL_SRCS})
-  add_definitions(-DTVM_METAL_RUNTIME=1)
-else(USE_METAL)
-  add_definitions(-DTVM_METAL_RUNTIME=0)
-endif(USE_METAL)
+# Package runtime rules
+if(NOT USE_RTTI)
+  add_definitions(-DDMLC_ENABLE_RTTI=0)
+endif()
 
 if(USE_RPC)
   message(STATUS "Build with RPC support...")
+  file(GLOB RUNTIME_RPC_SRCS src/runtime/rpc/*.cc)
   list(APPEND RUNTIME_SRCS ${RUNTIME_RPC_SRCS})
 endif(USE_RPC)
 
 if(USE_GRAPH_RUNTIME)
   message(STATUS "Build with Graph runtime support...")
+  file(GLOB RUNTIME_GRAPH_SRCS src/runtime/graph/*.cc)
   list(APPEND RUNTIME_SRCS ${RUNTIME_GRAPH_SRCS})
-endif(USE_GRAPH_RUNTIME)
-
-if(USE_LLVM)
-  find_package(LLVM CONFIG REQUIRED)
-  include_directories(${LLVM_INCLUDE_DIRS})
-  add_definitions(${LLVM_DEFINITIONS})
-  set(TVM_LLVM_VERSION ${LLVM_VERSION_MAJOR}${LLVM_VERSION_MINOR})
-  message(STATUS "Build with LLVM " ${LLVM_PACKAGE_VERSION})
-  message(STATUS "Set TVM_LLVM_VERSION=" ${TVM_LLVM_VERSION})
-  add_definitions(-DTVM_LLVM_VERSION=${TVM_LLVM_VERSION})
-  add_definitions(-DDMLC_USE_FOPEN64=0)
-  llvm_map_components_to_libnames(LLVM_LIBS all)
-  list(REMOVE_ITEM LLVM_LIBS LTO)
-  list(APPEND TVM_LINKER_LIBS ${LLVM_LIBS})
-  list(APPEND COMPILER_SRCS ${COMPILER_LLVM_SRCS})
-  if(NOT MSVC)
-    set_property(SOURCE ${COMPILER_LLVM_SRCS} APPEND_STRING PROPERTY COMPILE_FLAGS
-      "-fno-rtti -DDMLC_ENABLE_RTTI=0")
-  endif()
-endif(USE_LLVM)
 
-if(NOT USE_RTTI)
-  add_definitions(-DDMLC_ENABLE_RTTI=0)
-endif()
+  if(USE_GRAPH_RUNTIME_DEBUG)
+    set_source_files_properties(${RUNTIME_GRAPH_SRCS}
+      PROPERTIES COMPILE_DEFINITIONS "TVM_GRAPH_RUNTIME_DEBUG")
+  endif(USE_GRAPH_RUNTIME_DEBUG)
+endif(USE_GRAPH_RUNTIME)
 
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/dmlc-core/CMakeLists.txt)
   include_directories(${CMAKE_CURRENT_SOURCE_DIR}/dmlc-core/include)
@@ -259,18 +156,55 @@ elseif(DMLC_CORE_PATH)
   include_directories(${DMLC_CORE_PATH}/include)
 endif()
 
-list(APPEND RUNTIME_SRCS ${GROUP_Include})
+# Module rules
+include(cmake/modules/CUDA.cmake)
+include(cmake/modules/OpenCL.cmake)
+include(cmake/modules/OpenGL.cmake)
+include(cmake/modules/Vulkan.cmake)
+include(cmake/modules/Metal.cmake)
+include(cmake/modules/ROCM.cmake)
+include(cmake/modules/LLVM.cmake)
+include(cmake/modules/contrib/BLAS.cmake)
+include(cmake/modules/contrib/Random.cmake)
+include(cmake/modules/contrib/Sort.cmake)
+include(cmake/modules/contrib/NNPack.cmake)
+
+# Target rrules
 add_library(tvm SHARED ${COMPILER_SRCS} ${RUNTIME_SRCS})
 add_library(tvm_topi SHARED ${TOPI_SRCS})
 add_library(tvm_runtime SHARED ${RUNTIME_SRCS})
 add_library(nnvm_compiler SHARED ${NNVM_COMPILER_SRCS})
+
 target_link_libraries(tvm ${TVM_LINKER_LIBS} ${TVM_RUNTIME_LINKER_LIBS})
 target_link_libraries(tvm_topi tvm ${TVM_LINKER_LIBS} ${TVM_RUNTIME_LINKER_LIBS})
 target_link_libraries(tvm_runtime ${TVM_RUNTIME_LINKER_LIBS})
 target_link_libraries(nnvm_compiler tvm)
 
-install(TARGETS tvm_runtime DESTINATION lib${LIB_SUFFIX})
+# Tests
+set(TEST_EXECS "")
+file(GLOB TEST_SRCS tests/cpp/*.cc)
+find_library(GTEST_LIB gtest)
+
+if(GTEST_LIB)
+  foreach(__srcpath ${TEST_SRCS})
+    get_filename_component(__srcname ${__srcpath} NAME)
+    string(REPLACE ".cc" "" __execname ${__srcname})
+    add_executable(${__execname} ${__srcpath})
+    list(APPEND TEST_EXECS ${__execname})
+    target_link_libraries(${__execname}
+      tvm ${GTEST_LIB} ${TVM_LINKER_LIBS} ${TVM_RUNTIME_LINKER_LIBS} pthread)
+    set_target_properties(${__execname} PROPERTIES EXCLUDE_FROM_ALL 1)
+    set_target_properties(${__execname} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD 1)
+  endforeach()
+  add_custom_target(cpptest DEPENDS ${TEST_EXECS})
+endif()
 
+# Custom targets
+add_custom_target(runtime DEPENDS tvm_runtime)
+
+
+# Installation rulse
+install(TARGETS tvm_runtime DESTINATION lib${LIB_SUFFIX})
 if(WIN32)
   install(TARGETS nnvm_compiler RUNTIME DESTINATION bin)
   install(TARGETS nnvm_compiler ARCHIVE DESTINATION lib)
@@ -313,6 +247,7 @@ else(INSTALL_DEV)
     )
 endif(INSTALL_DEV)
 
+# More target definitions
 if(MSVC)
   target_compile_definitions(tvm PRIVATE -DHalide_EXPORTS)
   target_compile_definitions(tvm_runtime PRIVATE -DHalide_EXPORTS)