🎂 Project initialized!

.gitignore

@@ -0,0 +1,5 @@
+# IDE
+.vs/
+.idea/
+.vscode/
+*.iml

CMakeLists.txt

@@ -0,0 +1,314 @@
+cmake_minimum_required(VERSION 3.2)
+project(tvm C CXX)
+
+# Utility functions
+include(cmake/util/Util.cmake)
+include(cmake/util/FindCUDA.cmake)
+include(cmake/util/FindVulkan.cmake)
+include(cmake/util/FindLLVM.cmake)
+include(cmake/util/FindROCM.cmake)
+
+if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/config.cmake)
+  include(${CMAKE_CURRENT_BINARY_DIR}/config.cmake)
+else()
+  if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/config.cmake)
+    include(${CMAKE_CURRENT_SOURCE_DIR}/config.cmake)
+  endif()
+endif()
+
+# NOTE: do not modify this file to change option values.
+# 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" ON)
+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" ON)
+tvm_option(USE_STACKVM_RUNTIME "Include stackvm into the runtime" OFF)
+tvm_option(USE_GRAPH_RUNTIME "Build with tiny graph runtime" ON)
+tvm_option(USE_GRAPH_RUNTIME_DEBUG "Build with tiny graph runtime debug mode" OFF)
+tvm_option(USE_RELAY_DEBUG "Building Relay in debug mode..." OFF)
+tvm_option(USE_SGX "Build with SGX" 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)
+tvm_option(HIDE_PRIVATE_SYMBOLS "Compile with -fvisibility=hidden." OFF)
+
+# 3rdparty libraries
+tvm_option(DLPACK_PATH "Path to DLPACK" "3rdparty/dlpack/include")
+tvm_option(DMLC_PATH "Path to DMLC" "3rdparty/dmlc-core/include")
+tvm_option(RANG_PATH "Path to RANG" "3rdparty/rang/include")
+tvm_option(COMPILER_RT_PATH "Path to COMPILER-RT" "3rdparty/compiler-rt")
+
+# Contrib library options
+tvm_option(USE_BLAS "The blas library to be linked" none)
+tvm_option(USE_MKL_PATH "MKL root path when use MKL blas" 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)
+tvm_option(USE_ANTLR "Build with ANTLR for Relay parsing" OFF)
+
+# include directories
+include_directories(${CMAKE_INCLUDE_PATH})
+include_directories("include")
+include_directories(${DLPACK_PATH})
+include_directories(${DMLC_PATH})
+include_directories(${RANG_PATH})
+include_directories(${COMPILER_RT_PATH})
+
+# initial variables
+set(TVM_LINKER_LIBS "")
+set(TVM_RUNTIME_LINKER_LIBS ${CMAKE_DL_LIBS})
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# Generic compilation options
+if(MSVC)
+  add_definitions(-DWIN32_LEAN_AND_MEAN)
+  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+  add_definitions(-D_SCL_SECURE_NO_WARNINGS)
+  add_definitions(-D_ENABLE_EXTENDED_ALIGNED_STORAGE)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /bigobj")
+  if(USE_MSVC_MT)
+    foreach(flag_var
+        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+      if(${flag_var} MATCHES "/MD")
+        string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+      endif(${flag_var} MATCHES "/MD")
+    endforeach(flag_var)
+  endif()
+else(MSVC)
+  include(CheckCXXCompilerFlag)
+  check_cxx_compiler_flag("-std=c++11"    SUPPORT_CXX11)
+  if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
+    message("Build in Debug mode")
+    set(CMAKE_C_FLAGS "-O0 -g -Wall -fPIC ${CMAKE_C_FLAGS} -rdynamic")
+    set(CMAKE_CXX_FLAGS "-O0 -g -Wall -fPIC -std=c++11 ${CMAKE_CXX_FLAGS} -rdynamic")
+  else()
+    set(CMAKE_C_FLAGS "-O2 -Wall -fPIC ${CMAKE_C_FLAGS}")
+    set(CMAKE_CXX_FLAGS "-O2 -Wall -fPIC -std=c++11 ${CMAKE_CXX_FLAGS}")
+    if (HIDE_PRIVATE_SYMBOLS)
+      message("Hide private symbols...")
+      set(CMAKE_C_FLAGS "-fvisibility=hidden ${CMAKE_C_FLAGS}")
+      set(CMAKE_CXX_FLAGS "-fvisibility=hidden ${CMAKE_CXX_FLAGS}")
+    endif(HIDE_PRIVATE_SYMBOLS)
+  endif ()
+  if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND
+      CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0)
+    set(CMAKE_CXX_FLAGS "-faligned-new ${CMAKE_CXX_FLAGS}")
+  endif()
+endif(MSVC)
+
+# add source group
+FILE(GLOB_RECURSE GROUP_SOURCE "src/*.cc" "nnvm/src/*.cc")
+FILE(GLOB_RECURSE GROUP_INCLUDE "src/*.h" "include/*.h"
+                                "nnvm/src/*.h" "nnvm/include/*.h")
+assign_source_group("Source" ${GROUP_SOURCE})
+assign_source_group("Include" ${GROUP_INCLUDE})
+
+# Source file lists
+file(GLOB COMPILER_SRCS
+    src/api/*.cc
+    src/arithmetic/*.cc
+    src/autotvm/*.cc
+    src/codegen/*.cc
+    src/lang/*.cc
+    src/pass/*.cc
+    src/op/*.cc
+    src/node/*.cc
+    src/schedule/*.cc
+    )
+
+file(GLOB_RECURSE RELAY_SRCS
+    src/relay/*.cc
+    )
+list(APPEND COMPILER_SRCS ${RELAY_SRCS})
+
+file(GLOB DATATYPE_SRCS src/codegen/datatype/*.cc)
+list(APPEND COMPILER_SRCS ${DATATYPE_SRCS})
+
+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
+    nnvm/src/pass/*.cc
+    nnvm/src/compiler/*.cc
+    nnvm/src/top/*.cc
+    )
+
+file(GLOB TOPI_SRCS
+    topi/src/*.cc
+)
+
+file(GLOB RUNTIME_SRCS
+  src/runtime/*.cc
+  src/runtime/vm/*.cc
+)
+
+# Package runtime rules
+if(NOT USE_RTTI)
+  add_definitions(-DDMLC_ENABLE_RTTI=0)
+endif()
+
+list(APPEND RUNTIME_SRCS 3rdparty/bfloat16/bfloat16.cc)
+
+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)
+
+file(GLOB STACKVM_RUNTIME_SRCS src/runtime/stackvm/*.cc)
+file(GLOB STACKVM_CODEGEN_SRCS src/codegen/stackvm/*.cc)
+list(APPEND COMPILER_SRCS ${STACKVM_CODEGEN_SRCS})
+if(USE_STACKVM_RUNTIME)
+  message(STATUS "Build with stackvm support in runtime...")
+  list(APPEND RUNTIME_SRCS ${STACKVM_RUNTIME_SRCS})
+else()
+  list(APPEND COMPILER_SRCS ${STACKVM_RUNTIME_SRCS})
+endif(USE_STACKVM_RUNTIME)
+
+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})
+
+  if(USE_GRAPH_RUNTIME_DEBUG)
+    message(STATUS "Build with Graph runtime debug support...")
+    file(GLOB RUNTIME_GRAPH_DEBUG_SRCS src/runtime/graph/debug/*.cc)
+    list(APPEND RUNTIME_SRCS ${RUNTIME_GRAPH_DEBUG_SRCS})
+    set_source_files_properties(${RUNTIME_GRAPH_SRCS}
+      PROPERTIES COMPILE_DEFINITIONS "TVM_GRAPH_RUNTIME_DEBUG")
+  endif(USE_GRAPH_RUNTIME_DEBUG)
+endif(USE_GRAPH_RUNTIME)
+
+# Module rules
+include(cmake/modules/VTA.cmake)
+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/SGX.cmake)
+include(cmake/modules/LLVM.cmake)
+include(cmake/modules/ANTLR.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)
+include(cmake/modules/contrib/HybridDump.cmake)
+
+add_library(tvm SHARED ${COMPILER_SRCS} ${RUNTIME_SRCS})
+add_library(tvm_topi SHARED ${TOPI_SRCS})
+add_library(tvm_runtime SHARED ${RUNTIME_SRCS})
+
+if(USE_RELAY_DEBUG)
+  message(STATUS "Building Relay in debug mode...")
+  set_target_properties(tvm PROPERTIES COMPILE_DEFINITIONS "USE_RELAY_DEBUG")
+else()
+  set_target_properties(tvm PROPERTIES COMPILE_DEFINITIONS "NDEBUG")
+endif(USE_RELAY_DEBUG)
+
+if(NOT USE_SGX STREQUAL "OFF")
+  add_dependencies(tvm sgx_edl)
+  add_dependencies(tvm_runtime sgx_edl tvm_t)
+  install(TARGETS tvm_t ARCHIVE DESTINATION lib${LIB_SUFFIX})
+endif()
+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)
+
+# Related headers
+target_include_directories(
+  tvm
+  PUBLIC "topi/include")
+target_include_directories(
+  tvm_topi
+  PUBLIC "topi/include")
+target_include_directories(
+  nnvm_compiler
+  PUBLIC "nnvm/include"
+  PUBLIC "topi/include")
+
+# Tests
+set(TEST_EXECS "")
+file(GLOB TEST_SRCS tests/cpp/*.cc)
+find_library(GTEST_LIB gtest "$ENV{GTEST_LIB}")
+
+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} pthread dl)
+    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 rules
+install(TARGETS tvm DESTINATION lib${LIB_SUFFIX})
+install(TARGETS tvm_topi DESTINATION lib${LIB_SUFFIX})
+install(TARGETS tvm_runtime DESTINATION lib${LIB_SUFFIX})
+install(TARGETS nnvm_compiler DESTINATION lib${LIB_SUFFIX})
+
+if (INSTALL_DEV)
+  install(
+    DIRECTORY "include/." DESTINATION "include"
+    FILES_MATCHING
+    PATTERN "*.h"
+  )
+  install(
+    DIRECTORY "topi/include/." DESTINATION "include"
+    FILES_MATCHING
+    PATTERN "*.h"
+  )
+  install(
+    DIRECTORY "3rdparty/dlpack/include/." DESTINATION "include"
+    FILES_MATCHING
+    PATTERN "*.h"
+    )
+  install(
+    DIRECTORY "nnvm/include/." DESTINATION "include"
+    FILES_MATCHING
+    PATTERN "*.h"
+    )
+else(INSTALL_DEV)
+  install(
+    DIRECTORY "include/tvm/runtime/." DESTINATION "include/tvm/runtime"
+    FILES_MATCHING
+    PATTERN "*.h"
+    )
+endif(INSTALL_DEV)
+
+# More target definitions
+if(MSVC)
+  target_compile_definitions(tvm PRIVATE -DTVM_EXPORTS)
+  target_compile_definitions(tvm_runtime PRIVATE -DTVM_EXPORTS)
+  target_compile_definitions(nnvm_compiler PRIVATE -DNNVM_EXPORTS)
+endif()

Readme.md

@@ -0,0 +1,44 @@
+TVM CLib(Binary dependence) for Windows
+=======================================
+
+Pre-build with CUDA support, LLVM support.
+
+The environment variables are as follows:
+
+```log
+-- Selecting Windows SDK version 10.0.17763.0 to target Windows 10.0.17134.
+-- The C compiler identification is MSVC 19.21.27702.2
+-- The CXX compiler identification is MSVC 19.21.27702.2
+-- Check for working C compiler: C:/Program Files (x86)/Microsoft Visual Studio/2019/VC/Tools/MSVC/14.21.27702/bin/Hostx64/x64/cl.exe
+-- Check for working C compiler: C:/Program Files (x86)/Microsoft Visual Studio/2019/VC/Tools/MSVC/14.21.27702/bin/Hostx64/x64/cl.exe -- works
+-- Detecting C compiler ABI info
+-- Detecting C compiler ABI info - done
+-- Detecting C compile features
+-- Detecting C compile features - done
+-- Check for working CXX compiler: C:/Program Files (x86)/Microsoft Visual Studio/2019/VC/Tools/MSVC/14.21.27702/bin/Hostx64/x64/cl.exe
+-- Check for working CXX compiler: C:/Program Files (x86)/Microsoft Visual Studio/2019/VC/Tools/MSVC/14.21.27702/bin/Hostx64/x64/cl.exe -- works
+-- Detecting CXX compiler ABI info
+-- Detecting CXX compiler ABI info - done
+-- Detecting CXX compile features
+-- Detecting CXX compile features - done
+-- Build with RPC support...
+-- Build with Graph runtime support...
+-- VTA build is skipped in Windows..
+-- Found CUDA_TOOLKIT_ROOT_DIR=C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v9.2
+-- Found CUDA_CUDA_LIBRARY=C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v9.2/lib/x64/cuda.lib
+-- Found CUDA_CUDART_LIBRARY=C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v9.2/lib/x64/cudart.lib
+-- Found CUDA_NVRTC_LIBRARY=C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v9.2/lib/x64/nvrtc.lib
+-- Found CUDA_CUDNN_LIBRARY=C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v9.2/lib/x64/cudnn.lib
+-- Found CUDA_CUBLAS_LIBRARY=C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v9.2/lib/x64/cublas.lib
+-- Build with CUDA support
+-- Link with static LLVM libraries
+-- Found LLVM_INCLUDE_DIRS=D:/Hybrid/LLVM/includeD:/Hybrid/LLVM/build/include
+-- Found LLVM_DEFINITIONS=-D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -DUNICODE -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+-- Found TVM_LLVM_VERSION=70
+-- Build with LLVM 7.0.1
+-- Set TVM_LLVM_VERSION=70
+-- Build with contrib.hybriddump
+-- Configuring done
+-- Generating done
+-- Build files have been written to: D:/Hybrid/tvm/build
+```