llvm
/
torch-mlir
mirror of https://github.com/llvm/torch-mlir
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
torch-mlir/tools/npcomp-run-mlir/CMakeLists.txt

32 lines
764 B
CMake
Raw Normal View History

Start reworking towards a shared library build. * Need to have a dag of shared library deps in order to interop across python extensions (as presented in ODM). * Introduced add_npcomp_library and friends to mirror the MLIR setup. * Adds a libNPCOMP.so shared library. * Redirects tools and extensions to link against libNPCOMP.so (instead of static libs). * Moves all libraries to lib/, all binaries to bin/ and all python extensions to python/. The invariant is that the rpaths are setup to have a one level directory structure. * Reworks the _torch_mlir extension to build like the others (still need to come up with a consolidated rule to do this instead of open coded). * Includes an upstream version bump to pick up needed changes. Sizes with dynamic linking (stripped, release, asserts enabled): libNPCOMP.so: 43M (includes much of the underlying LLVM codegen deps) libMLIR.so: 31M _npcomp.so: 1.6M (python extension) _torch_mlir.so: 670K (python extension) npcomp-capi-ir-test: 6.3K npcomp-opt: 351K npcomp-run-mlir: 461K mnist-playground: 530K Still more can be done to normalize and optimize but this gets us structurally to the starting point.
2020-10-09 09:29:59 +08:00
# npcomp-run-mlir is always linked dynamically as we want to distribute the
# binaries with the python packages for hacking/debugging.
get_property(dialect_libs GLOBAL PROPERTY NPCOMP_DIALECT_LIBS)
get_property(conversion_libs GLOBAL PROPERTY NPCOMP_CONVERSION_LIBS)
Add bare-bones npcomp-run-mlir. The code isn't super clean, but is a useful incremental step establishing most of the boilerplate for future enhancements. We can't print or return tensors yet so correctness TBD, but I've stepped into the running code in the debugger so I know it definitely is running. This is the first step to building out an npcomp mini-runtime. The mini-runtime doesn't have to be fancy or complex, but it should at least be layered nicely (which this code and the current compiler interaction with the "runtime" code is not). Now that we have boilerplate for e2e execution in some form, we can build that out.
2020-05-29 07:41:36 +08:00
Start reworking towards a shared library build. * Need to have a dag of shared library deps in order to interop across python extensions (as presented in ODM). * Introduced add_npcomp_library and friends to mirror the MLIR setup. * Adds a libNPCOMP.so shared library. * Redirects tools and extensions to link against libNPCOMP.so (instead of static libs). * Moves all libraries to lib/, all binaries to bin/ and all python extensions to python/. The invariant is that the rpaths are setup to have a one level directory structure. * Reworks the _torch_mlir extension to build like the others (still need to come up with a consolidated rule to do this instead of open coded). * Includes an upstream version bump to pick up needed changes. Sizes with dynamic linking (stripped, release, asserts enabled): libNPCOMP.so: 43M (includes much of the underlying LLVM codegen deps) libMLIR.so: 31M _npcomp.so: 1.6M (python extension) _torch_mlir.so: 670K (python extension) npcomp-capi-ir-test: 6.3K npcomp-opt: 351K npcomp-run-mlir: 461K mnist-playground: 530K Still more can be done to normalize and optimize but this gets us structurally to the starting point.
2020-10-09 09:29:59 +08:00
add_npcomp_executable(npcomp-run-mlir
Add bare-bones npcomp-run-mlir. The code isn't super clean, but is a useful incremental step establishing most of the boilerplate for future enhancements. We can't print or return tensors yet so correctness TBD, but I've stepped into the running code in the debugger so I know it definitely is running. This is the first step to building out an npcomp mini-runtime. The mini-runtime doesn't have to be fancy or complex, but it should at least be layered nicely (which this code and the current compiler interaction with the "runtime" code is not). Now that we have boilerplate for e2e execution in some form, we can build that out.
2020-05-29 07:41:36 +08:00
npcomp-run-mlir.cpp
)
Start reworking towards a shared library build. * Need to have a dag of shared library deps in order to interop across python extensions (as presented in ODM). * Introduced add_npcomp_library and friends to mirror the MLIR setup. * Adds a libNPCOMP.so shared library. * Redirects tools and extensions to link against libNPCOMP.so (instead of static libs). * Moves all libraries to lib/, all binaries to bin/ and all python extensions to python/. The invariant is that the rpaths are setup to have a one level directory structure. * Reworks the _torch_mlir extension to build like the others (still need to come up with a consolidated rule to do this instead of open coded). * Includes an upstream version bump to pick up needed changes. Sizes with dynamic linking (stripped, release, asserts enabled): libNPCOMP.so: 43M (includes much of the underlying LLVM codegen deps) libMLIR.so: 31M _npcomp.so: 1.6M (python extension) _torch_mlir.so: 670K (python extension) npcomp-capi-ir-test: 6.3K npcomp-opt: 351K npcomp-run-mlir: 461K mnist-playground: 530K Still more can be done to normalize and optimize but this gets us structurally to the starting point.
2020-10-09 09:29:59 +08:00
Add bare-bones npcomp-run-mlir. The code isn't super clean, but is a useful incremental step establishing most of the boilerplate for future enhancements. We can't print or return tensors yet so correctness TBD, but I've stepped into the running code in the debugger so I know it definitely is running. This is the first step to building out an npcomp mini-runtime. The mini-runtime doesn't have to be fancy or complex, but it should at least be layered nicely (which this code and the current compiler interaction with the "runtime" code is not). Now that we have boilerplate for e2e execution in some form, we can build that out.
2020-05-29 07:41:36 +08:00
llvm_update_compile_flags(npcomp-run-mlir)
target_link_libraries(npcomp-run-mlir PRIVATE
Start reworking towards a shared library build. * Need to have a dag of shared library deps in order to interop across python extensions (as presented in ODM). * Introduced add_npcomp_library and friends to mirror the MLIR setup. * Adds a libNPCOMP.so shared library. * Redirects tools and extensions to link against libNPCOMP.so (instead of static libs). * Moves all libraries to lib/, all binaries to bin/ and all python extensions to python/. The invariant is that the rpaths are setup to have a one level directory structure. * Reworks the _torch_mlir extension to build like the others (still need to come up with a consolidated rule to do this instead of open coded). * Includes an upstream version bump to pick up needed changes. Sizes with dynamic linking (stripped, release, asserts enabled): libNPCOMP.so: 43M (includes much of the underlying LLVM codegen deps) libMLIR.so: 31M _npcomp.so: 1.6M (python extension) _torch_mlir.so: 670K (python extension) npcomp-capi-ir-test: 6.3K npcomp-opt: 351K npcomp-run-mlir: 461K mnist-playground: 530K Still more can be done to normalize and optimize but this gets us structurally to the starting point.
2020-10-09 09:29:59 +08:00
# Shared library deps first ensure we get most of what we need from libraries.
NPCOMP
MLIR
NPCOMPCAPI
Add bare-bones npcomp-run-mlir. The code isn't super clean, but is a useful incremental step establishing most of the boilerplate for future enhancements. We can't print or return tensors yet so correctness TBD, but I've stepped into the running code in the debugger so I know it definitely is running. This is the first step to building out an npcomp mini-runtime. The mini-runtime doesn't have to be fancy or complex, but it should at least be layered nicely (which this code and the current compiler interaction with the "runtime" code is not). Now that we have boilerplate for e2e execution in some form, we can build that out.
2020-05-29 07:41:36 +08:00
MLIRAnalysis
MLIREDSC
MLIRIR
MLIRJitRunner
MLIRParser
MLIRSupport
Make a real library for InitAll and extend it to conditionally initialize dependencies. * Conditioned on the top level CMake option to enable IREE. * There is still some warning flags and such that need triage, but it does build/work.
2020-06-12 08:47:14 +08:00
NPCOMPInitAll
[RefBackend] Move runtime related code under npcomp/RefBackend/ Other than the dialect definitions (which will live in standard Dialect/ subdirectory), the goal here is to keep RefBackend-related code nested in {include/npcomp,lib,test}/RefBackend.
2020-10-08 07:11:41 +08:00
NPCOMPRefBackendJITHelpers
Misc fixes to enable building/testing on manylinux2014 images. * Since the manylinux images do not hard-link against python libs (resolving them at runtime), the module must be built without resolving undefined references. * For some reason, builds on this platform are stricter, exposing dependency ordering issues. * The CMake bits to build the extension are still somewhat of a mess. I have better versions both upstream and in IREE and will be reconciling. For now, don't look too closely.
2020-08-05 08:10:14 +08:00
${conversion_libs}
${dialect_libs}
Start reworking towards a shared library build. * Need to have a dag of shared library deps in order to interop across python extensions (as presented in ODM). * Introduced add_npcomp_library and friends to mirror the MLIR setup. * Adds a libNPCOMP.so shared library. * Redirects tools and extensions to link against libNPCOMP.so (instead of static libs). * Moves all libraries to lib/, all binaries to bin/ and all python extensions to python/. The invariant is that the rpaths are setup to have a one level directory structure. * Reworks the _torch_mlir extension to build like the others (still need to come up with a consolidated rule to do this instead of open coded). * Includes an upstream version bump to pick up needed changes. Sizes with dynamic linking (stripped, release, asserts enabled): libNPCOMP.so: 43M (includes much of the underlying LLVM codegen deps) libMLIR.so: 31M _npcomp.so: 1.6M (python extension) _torch_mlir.so: 670K (python extension) npcomp-capi-ir-test: 6.3K npcomp-opt: 351K npcomp-run-mlir: 461K mnist-playground: 530K Still more can be done to normalize and optimize but this gets us structurally to the starting point.
2020-10-09 09:29:59 +08:00
)
Rework e2e flow to use new "npcomprt" This ~totally reworks the existing "runtime" stuff to be more principled and usable, such as from Python. It's still not fully production-quality, mainly in the department of memory management (e.g. it currently leaks memory; we need to figure out "who frees memrefs" + the analysis and transformation needed to do that (maybe use upstream buffer allocation pass?)). The user API is in include/npcomp/runtime/UserAPI.h, though include/npcomp/JITRuntime/JITModule.h is a friendlier wrapper. The stuff under {include,lib}/runtime is totally firewalled from the compiler and tiny (<6kB, though no attention has gone into optimizing that size). For example, we don't link in libSupport into the runtime, instead having our own bare bones replacements for basics like ArrayRef (the JITRuntime helps with bridging that gap, since it *can* depend on all common LLVM utilities). The overall features of npcomprt is that it exposes a module that with multiple function entry points. Each function has arguments and results that are tensor-valued, and npcomprt::Tensor is the runtime type that is used to interact with that (and a npcomprt::Ref<T> reference-counting wrapper is provided to wrap npcomprt::Tensor in the common case). From an implementation perspective, an npcomprt module at the LLVM/object/binary level exposes a single module descriptor struct that has pointers to other metadata (currently just a list of function metadata descriptors). All interactions with the npcomp runtime are keyed off of that module descriptor, including function lookups and dispatching. This is done to dodge platform ABI issues and also allow enough reflection to e.g. verify provided arguments. Most of the compiler-side work here was in LowerToNpcomprtABI and LowerToLLVM. Also, - Rename npcomp_rt/NpcompRt to npcomprt/Npcomprt; it was getting annoying to type the underscores/caps. - misc improvements to bash_helpers.sh
2020-07-09 08:15:40 +08:00
add_dependencies(npcomp-run-mlir
NPCOMPCompilerRuntimeShlib
Add bare-bones npcomp-run-mlir. The code isn't super clean, but is a useful incremental step establishing most of the boilerplate for future enhancements. We can't print or return tensors yet so correctness TBD, but I've stepped into the running code in the debugger so I know it definitely is running. This is the first step to building out an npcomp mini-runtime. The mini-runtime doesn't have to be fancy or complex, but it should at least be layered nicely (which this code and the current compiler interaction with the "runtime" code is not). Now that we have boilerplate for e2e execution in some form, we can build that out.
2020-05-29 07:41:36 +08:00
)