2020-11-14 08:07:57 +08:00
cmake_minimum_required ( VERSION 3.12 )
2020-04-27 07:26:45 +08:00
if ( POLICY CMP0068 )
cmake_policy ( SET CMP0068 NEW )
set ( CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON )
endif ( )
if ( POLICY CMP0075 )
cmake_policy ( SET CMP0075 NEW )
endif ( )
if ( POLICY CMP0077 )
cmake_policy ( SET CMP0077 NEW )
endif ( )
2020-06-12 07:40:31 +08:00
#-------------------------------------------------------------------------------
# Project setup and globals
#-------------------------------------------------------------------------------
2020-04-27 08:55:15 +08:00
project ( npcomp LANGUAGES CXX C )
2020-06-12 07:40:31 +08:00
set ( CMAKE_C_STANDARD 11 )
set ( CMAKE_CXX_STANDARD 14 )
2020-07-05 08:38:01 +08:00
list ( APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules" )
2020-04-27 07:26:45 +08:00
2020-06-12 07:40:31 +08:00
#-------------------------------------------------------------------------------
# Options and settings
#-------------------------------------------------------------------------------
option ( NPCOMP_ENABLE_IREE "Enables the IREE backend (must configure location via IREE_DIR)." OFF )
2020-07-11 08:36:32 +08:00
option ( NPCOMP_ENABLE_REFJIT "Enables the reference JIT backend." ON )
2020-10-09 09:29:59 +08:00
option ( NPCOMP_BUILD_NPCOMP_DYLIB "Enables shared build of NPCOMP dylib (depends on LLVM/MLIR dylib support)" ON )
2020-11-14 10:06:59 +08:00
set ( NPCOMP_IREE_BUILDDIR "../iree-build" CACHE STRING "If building IREE, then setting this elects to build from a source directory (versus installed package)" )
2020-11-14 08:07:57 +08:00
set ( NPCOMP_ENABLE_PYTORCH "OPTIONAL" CACHE STRING "Enables the PyTorch frontend (OFF, OPTIONAL, REQUIRED)" )
2020-06-12 07:40:31 +08:00
2020-11-04 05:46:46 +08:00
# Turn on -gsplit-dwarf if requested in debug builds.
if ( NPCOMP_USE_SPLIT_DWARF AND
( ( C M A K E _ B U I L D _ T Y P E S T R E Q U A L " D e b u g " ) O R
( C M A K E _ B U I L D _ T Y P E S T R E Q U A L " R e l W i t h D e b I n f o " ) ) )
# Limit to clang and gcc so far. Add compilers supporting this option.
if ( CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR
C M A K E _ C X X _ C O M P I L E R _ I D S T R E Q U A L " G N U " )
add_compile_options ( -gsplit-dwarf )
endif ( )
endif ( )
2020-07-02 12:28:04 +08:00
#-------------------------------------------------------------------------------
# MSVC defaults
#-------------------------------------------------------------------------------
if ( MSVC )
add_compile_options (
$ < $ < C O N F I G : > : / M D >
$ < $ < C O N F I G : D e b u g > : / M D >
$ < $ < C O N F I G : R e l e a s e > : / M D >
)
endif ( )
2020-06-12 07:40:31 +08:00
#-------------------------------------------------------------------------------
# MLIR/LLVM Configuration
#-------------------------------------------------------------------------------
2020-04-27 07:26:45 +08:00
2020-06-12 07:40:31 +08:00
find_package ( MLIR REQUIRED CONFIG )
2020-04-27 07:26:45 +08:00
message ( STATUS "Using MLIRConfig.cmake in: ${MLIR_DIR}" )
message ( STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}" )
2020-08-06 05:49:18 +08:00
#set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/bin)
set ( LLVM_LIBRARY_OUTPUT_INTDIR ${ CMAKE_BINARY_DIR } /lib )
# Define the default arguments to use with 'lit', and an option for the user to
# override.
set ( LIT_ARGS_DEFAULT "-sv" )
if ( MSVC_IDE OR XCODE )
set ( LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar" )
endif ( )
set ( LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit" )
2020-04-27 07:26:45 +08:00
list ( APPEND CMAKE_MODULE_PATH "${MLIR_CMAKE_DIR}" )
list ( APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}" )
include ( TableGen )
include ( AddLLVM )
include ( AddMLIR )
2020-10-09 09:29:59 +08:00
include ( AddNPCOMP )
2020-04-27 07:26:45 +08:00
include ( HandleLLVMOptions )
2020-11-14 08:07:57 +08:00
include ( ConfigurePyTorch )
2020-04-27 07:26:45 +08:00
include_directories ( ${ LLVM_INCLUDE_DIRS } )
include_directories ( ${ MLIR_INCLUDE_DIRS } )
include_directories ( ${ PROJECT_SOURCE_DIR } /include )
include_directories ( ${ PROJECT_BINARY_DIR } /include )
link_directories ( ${ LLVM_BUILD_LIBRARY_DIR } )
add_definitions ( ${ LLVM_DEFINITIONS } )
2020-06-14 14:45:43 +08:00
set ( NPCOMP_TABLEGEN_ARGS "" )
2020-04-27 07:26:45 +08:00
2020-07-11 08:36:32 +08:00
#-------------------------------------------------------------------------------
# Optional feature selection
#-------------------------------------------------------------------------------
if ( NPCOMP_ENABLE_REFJIT )
add_compile_definitions ( NPCOMP_ENABLE_REFJIT )
message ( STATUS "Reference JIT backend enabled" )
endif ( )
2020-06-12 07:40:31 +08:00
#-------------------------------------------------------------------------------
# IREE configuration
#-------------------------------------------------------------------------------
2020-06-12 08:47:14 +08:00
if ( NPCOMP_ENABLE_IREE )
2020-06-12 07:40:31 +08:00
add_compile_definitions ( NPCOMP_ENABLE_IREE )
2020-06-14 14:45:43 +08:00
string ( APPEND NPCOMP_TABLEGEN_ARGS "-DNPCOMP_ENABLE_IREE" )
2020-11-14 10:06:59 +08:00
if ( NPCOMP_IREE_BUILDDIR )
message ( STATUS "Depending on IREE build: ${NPCOMP_IREE_BUILDDIR}" )
set ( IREE_DIR "${NPCOMP_IREE_BUILDDIR}" )
set ( IREE_FOUND 1 )
2020-06-12 07:40:31 +08:00
else ( )
find_package ( IREE REQUIRED CONFIG )
endif ( )
2020-06-12 08:47:14 +08:00
2020-11-14 10:06:59 +08:00
# This is temporary until IREE properly supports installation. We splice
# the various files into where we want them.
function ( symlink_iree src dst )
set ( full_src_path "${IREE_DIR}/${src}" )
get_filename_component ( full_src_path "${full_src_path}" ABSOLUTE )
set ( full_dst_path "${CMAKE_CURRENT_BINARY_DIR}/${dst}" )
get_filename_component ( dst_dir ${ full_dst_path } PATH )
file ( MAKE_DIRECTORY "${dst_dir}" )
execute_process (
C O M M A N D
$ { C M A K E _ C O M M A N D } - E c r e a t e _ s y m l i n k " $ { f u l l _ s r c _ p a t h } " " $ { f u l l _ d s t _ p a t h } "
R E S U L T _ V A R I A B L E r e s u l t
)
if ( NOT ${ result } EQUAL 0 )
message ( FATAL_ERROR "Could not symlink iree file: ${full_src_path} -> ${full_dst_path}" )
endif ( )
endfunction ( )
symlink_iree ( iree/tools/iree-translate python/npcomp/compiler/generic/backend/iree-translate )
symlink_iree ( bindings/python/pyiree/rt python/pyiree/rt )
2020-06-12 07:40:31 +08:00
endif ( )
#-------------------------------------------------------------------------------
# Python Configuration
#-------------------------------------------------------------------------------
2020-04-27 06:50:23 +08:00
2020-08-05 08:10:14 +08:00
set ( NPCOMP_PYTHON_BINDINGS_VERSION_LOCKED 1 CACHE BOOL
" L i n k s t o s p e c i f i c p y t h o n l i b r a r i e s , r e s o l v i n g a l l s y m b o l s . " )
2020-11-14 08:07:57 +08:00
find_package ( Python3 COMPONENTS Interpreter Development REQUIRED )
message ( STATUS "Found python include dirs: ${Python3_INCLUDE_DIRS}" )
message ( STATUS "Found python libraries: ${Python3_LIBRARIES}" )
2020-04-27 06:50:23 +08:00
Add pytorch interface to ATen Dialect (#30)
This patch adds a pytorch interface to npcomp. This interface is modeled
after pytorch_xla and exposes the MLIR-based flow as a virtual device (similar
to a gpu device or the xla backend). Usage is intended to be something like:
dev = torch_mlir.mlir_device()
t0 = torch.randn((4,4), device=dev)
t1 = torch.randn((4,4), device=dev)
t2 = t0 + t1
t2_mlir = torch_mlir.get_mlir( t2 )
t2_cpu = t2.to('cpu')
In this case t2_cpu would contain the result of the computation, and t2_mlir
contains the mlir description of the computation. Note that this also
properly returns backward paths synthesized by pytorch. There are several
parts of this:
1) A tensor type (implemented by tensor.* and tensor_impl.*)
2) The device modeling (aten_mlir_bridge.*, aten_mlir_device.*, aten_mlir_type*)
3) a temporary IR (implemented by ir.cpp)
There is also a reference lowering directly from the ATen dialect to C
function calls consisting of two parts:
1) The driver that uses the IR to generate MLIR, run Passes and compile the
result using mlir::ExecutionEngine (implemented by jit.cpp and
mlir_gen.cpp)
2) A runtime library implemented by lib/aten_ops.cpp. Most of the operations
are implemented by callbacks into the torch C++ libraries.
Some aspects of this are known to be less than optimal, in particular:
1) There's some function definitions that don't live in the file corresponding
to their declaration.
2) More aspects of this (e.g. the IR) seem like they should be automatically
generated.
3) It's unclear to me how much of the 'IR' is actually necessary, or whether
MLIR could be created on the fly.
Note that this code is licensed in a way similar to pytorch, with the
intention that eventually (when npcomp reaches some maturity) it should be
pushed there. (see frontends/pytorch/LICENSE) The code is also structured
much closer to the pytorch coding style than the LLVM coding style.
2020-08-22 02:22:47 +08:00
#-------------------------------------------------------------------------------
# Pytorch Configuration
#-------------------------------------------------------------------------------
2020-11-14 08:07:57 +08:00
if ( NPCOMP_ENABLE_PYTORCH )
ProbeForPyTorchInstall ( )
2020-11-17 13:41:59 +08:00
if ( NPCOMP_ENABLE_PYTORCH STREQUAL "OPTIONAL" )
2020-11-14 08:07:57 +08:00
find_package ( Torch )
else ( )
find_package ( Torch REQUIRED )
endif ( )
endif ( )
#-------------------------------------------------------------------------------
# Pybind11 Configuration
#-------------------------------------------------------------------------------
find_package ( pybind11 CONFIG REQUIRED )
# TODO: pybind11 v2.6 switched from pybind11_INCLUDE_DIRS (plural) to
# pybind11_INCLUDE_DIR (singular). A lot has changed in this area since this
# was written and overall python config and pybind11 should be modernized.
set ( pybind11_INCLUDE_DIR ${ pybind11_INCLUDE_DIR } ${ pybind11_INCLUDE_DIRS } )
message ( STATUS "Found pybind11 v${pybind11_VERSION}: ${pybind11_INCLUDE_DIR}" )
message ( STATUS "Python prefix = '${PYTHON_MODULE_PREFIX}', "
" s u f f i x = ' $ { P Y T H O N _ M O D U L E _ S U F F I X } ' , "
" e x t e n s i o n = ' $ { P Y T H O N _ M O D U L E _ E X T E N S I O N } " )
Add pytorch interface to ATen Dialect (#30)
This patch adds a pytorch interface to npcomp. This interface is modeled
after pytorch_xla and exposes the MLIR-based flow as a virtual device (similar
to a gpu device or the xla backend). Usage is intended to be something like:
dev = torch_mlir.mlir_device()
t0 = torch.randn((4,4), device=dev)
t1 = torch.randn((4,4), device=dev)
t2 = t0 + t1
t2_mlir = torch_mlir.get_mlir( t2 )
t2_cpu = t2.to('cpu')
In this case t2_cpu would contain the result of the computation, and t2_mlir
contains the mlir description of the computation. Note that this also
properly returns backward paths synthesized by pytorch. There are several
parts of this:
1) A tensor type (implemented by tensor.* and tensor_impl.*)
2) The device modeling (aten_mlir_bridge.*, aten_mlir_device.*, aten_mlir_type*)
3) a temporary IR (implemented by ir.cpp)
There is also a reference lowering directly from the ATen dialect to C
function calls consisting of two parts:
1) The driver that uses the IR to generate MLIR, run Passes and compile the
result using mlir::ExecutionEngine (implemented by jit.cpp and
mlir_gen.cpp)
2) A runtime library implemented by lib/aten_ops.cpp. Most of the operations
are implemented by callbacks into the torch C++ libraries.
Some aspects of this are known to be less than optimal, in particular:
1) There's some function definitions that don't live in the file corresponding
to their declaration.
2) More aspects of this (e.g. the IR) seem like they should be automatically
generated.
3) It's unclear to me how much of the 'IR' is actually necessary, or whether
MLIR could be created on the fly.
Note that this code is licensed in a way similar to pytorch, with the
intention that eventually (when npcomp reaches some maturity) it should be
pushed there. (see frontends/pytorch/LICENSE) The code is also structured
much closer to the pytorch coding style than the LLVM coding style.
2020-08-22 02:22:47 +08:00
2020-06-12 07:40:31 +08:00
#-------------------------------------------------------------------------------
# Directory setup
#-------------------------------------------------------------------------------
set ( MLIR_NPCOMP_SOURCE_DIR ${ CMAKE_CURRENT_SOURCE_DIR } )
set ( MLIR_NPCOMP_BINARY_DIR ${ CMAKE_CURRENT_BINARY_DIR } )
2020-06-08 05:35:58 +08:00
add_custom_target ( check-npcomp )
Add pytorch interface to ATen Dialect (#30)
This patch adds a pytorch interface to npcomp. This interface is modeled
after pytorch_xla and exposes the MLIR-based flow as a virtual device (similar
to a gpu device or the xla backend). Usage is intended to be something like:
dev = torch_mlir.mlir_device()
t0 = torch.randn((4,4), device=dev)
t1 = torch.randn((4,4), device=dev)
t2 = t0 + t1
t2_mlir = torch_mlir.get_mlir( t2 )
t2_cpu = t2.to('cpu')
In this case t2_cpu would contain the result of the computation, and t2_mlir
contains the mlir description of the computation. Note that this also
properly returns backward paths synthesized by pytorch. There are several
parts of this:
1) A tensor type (implemented by tensor.* and tensor_impl.*)
2) The device modeling (aten_mlir_bridge.*, aten_mlir_device.*, aten_mlir_type*)
3) a temporary IR (implemented by ir.cpp)
There is also a reference lowering directly from the ATen dialect to C
function calls consisting of two parts:
1) The driver that uses the IR to generate MLIR, run Passes and compile the
result using mlir::ExecutionEngine (implemented by jit.cpp and
mlir_gen.cpp)
2) A runtime library implemented by lib/aten_ops.cpp. Most of the operations
are implemented by callbacks into the torch C++ libraries.
Some aspects of this are known to be less than optimal, in particular:
1) There's some function definitions that don't live in the file corresponding
to their declaration.
2) More aspects of this (e.g. the IR) seem like they should be automatically
generated.
3) It's unclear to me how much of the 'IR' is actually necessary, or whether
MLIR could be created on the fly.
Note that this code is licensed in a way similar to pytorch, with the
intention that eventually (when npcomp reaches some maturity) it should be
pushed there. (see frontends/pytorch/LICENSE) The code is also structured
much closer to the pytorch coding style than the LLVM coding style.
2020-08-22 02:22:47 +08:00
add_custom_target ( check-all )
add_dependencies ( check-all check-npcomp )
2020-06-08 05:35:58 +08:00
2020-04-27 06:50:23 +08:00
add_subdirectory ( include/npcomp )
add_subdirectory ( lib )
2020-08-05 08:10:14 +08:00
add_subdirectory ( python )
2020-04-27 08:55:15 +08:00
add_subdirectory ( test )
Add pytorch interface to ATen Dialect (#30)
This patch adds a pytorch interface to npcomp. This interface is modeled
after pytorch_xla and exposes the MLIR-based flow as a virtual device (similar
to a gpu device or the xla backend). Usage is intended to be something like:
dev = torch_mlir.mlir_device()
t0 = torch.randn((4,4), device=dev)
t1 = torch.randn((4,4), device=dev)
t2 = t0 + t1
t2_mlir = torch_mlir.get_mlir( t2 )
t2_cpu = t2.to('cpu')
In this case t2_cpu would contain the result of the computation, and t2_mlir
contains the mlir description of the computation. Note that this also
properly returns backward paths synthesized by pytorch. There are several
parts of this:
1) A tensor type (implemented by tensor.* and tensor_impl.*)
2) The device modeling (aten_mlir_bridge.*, aten_mlir_device.*, aten_mlir_type*)
3) a temporary IR (implemented by ir.cpp)
There is also a reference lowering directly from the ATen dialect to C
function calls consisting of two parts:
1) The driver that uses the IR to generate MLIR, run Passes and compile the
result using mlir::ExecutionEngine (implemented by jit.cpp and
mlir_gen.cpp)
2) A runtime library implemented by lib/aten_ops.cpp. Most of the operations
are implemented by callbacks into the torch C++ libraries.
Some aspects of this are known to be less than optimal, in particular:
1) There's some function definitions that don't live in the file corresponding
to their declaration.
2) More aspects of this (e.g. the IR) seem like they should be automatically
generated.
3) It's unclear to me how much of the 'IR' is actually necessary, or whether
MLIR could be created on the fly.
Note that this code is licensed in a way similar to pytorch, with the
intention that eventually (when npcomp reaches some maturity) it should be
pushed there. (see frontends/pytorch/LICENSE) The code is also structured
much closer to the pytorch coding style than the LLVM coding style.
2020-08-22 02:22:47 +08:00
add_subdirectory ( frontends )
2020-10-09 09:29:59 +08:00
# Tools needs to come late to ensure that NPCOMP_ALL_LIBS is populated.
# Generally things after this point may depend on NPCOMP_ALL_LIBS or libNPCOMP.so.
add_subdirectory ( tools )
