Proposed PyTorch integration

This commit proposes a set of **measured** low-overhead abstractions that
live side-by-side with the current pybind.
The idea is to show by example what a low-overhead abstraction for
PyTorch should look like and shift to that in a subsequent PR.

In particular the changes to the bindings include:
1. implement a compilation cache that performs memoization by hashing
TensorInfo on each call. This is required because PyTorch autograd functions
are stateless and we need to allocate outputs ourselves;
2. implement an explicit Tuner that takes a configuration object, preset to
good default values to avoid making it too easy to call the tuner in single
threaded mode;
3. implement an explicit interface to the compilation cache and allow
loading the topK options;

On the python side, this commit creates:
1. a TcBuilder class which makes a Tc operation usable by:
   a. providing an entry point to the compilation cache on which we can
      compile, alloc_outputs and run/unchecked_run  (we can later
      implement an idiom which just call directly into the compiled code if
      needed);
   b. providing an abstraction with or without reinforcement to an underlying
      tuner object backed by a proto file;
   c. being passed as the first argument to a TcFunction which implements
      torch.autograd.Function
2. a TcFunction which extends torch.autograd.Function and can take multiple TC
names to run in sequence for forward and backward. In the current impl there is
a potential synchronization problem that I want to be able to reproduce in the
future. This issue goes away in the next commit once output allocation is merged
at the C++ level.

This commit does a first functional implementation, the following commit
will remove extra overhead by merging the output allocation (which also seemd to
remove the synchronization issue that I do not know how to solve yet).

Author: nicolasvasilache

tc/autotuner/options_cache-inl.h

@@ -336,10 +336,10 @@ std::vector<typename Backend::MappingOptionsType> loadTopKFromCacheFile(
 
 template <typename Backend>
 void appendTopKToCacheFile(
-    const std::shared_ptr<OptionsCache<Backend>>& cache,
+    const OptionsCache<Backend>& cache,
     const std::string& cacheFilename,
     uint32_t count) {
-  OptionsCache<Backend> copy(*cache);
+  OptionsCache<Backend> copy(cache);
   copy.pruneKeepTopK(count);
   auto proto = copy.toProtobuf();
   OptionsCache<Backend> optionsCache;

tc/autotuner/options_cache.h

@@ -166,9 +166,10 @@ struct OptionsCache {
       OptionsCacheKeyHash>
       store_;
 
+  // Make friend to access toProtobuf/fromProtobuf
   template <typename BackendType>
   friend void appendTopKToCacheFile(
-      const std::shared_ptr<OptionsCache<BackendType>>& cache,
+      const OptionsCache<BackendType>& cache,
       const std::string& cacheFilename,
       uint32_t count);
 };
@@ -199,7 +200,7 @@ std::vector<typename Backend::MappingOptionsType> loadTopKFromCacheFile(
 /// needed.
 template <typename Backend>
 void appendTopKToCacheFile(
-    const std::shared_ptr<OptionsCache<Backend>>& cache,
+    const OptionsCache<Backend>& cache,
     const std::string& cacheFilename,
     uint32_t count);
 

tc/examples/blockdiagperm.cc

@@ -148,7 +148,7 @@ def blockdiagperm2dfissioned_2(float(B, N) I, int32(N) Idx) -> (O) {
   // later if required
   if (not FLAGS_options_cache.empty()) {
     tc::autotune::appendTopKToCacheFile(
-        geneticAutotuneATen.optionsCache,
+        *geneticAutotuneATen.optionsCache,
         FLAGS_options_cache,
         tc::FLAGS_tuner_save_best_candidates_count);
   }

tensor_comprehensions/pybinds/CMakeLists.txt

@@ -26,3 +26,22 @@ set_target_properties(tc PROPERTIES DEBUG_POSTFIX "")
 # "Install" to source_dir/tensor_comprehensions for easy inclusion in python
 # package with setuptools. Without this, setuptools is hell.
 install(TARGETS tc DESTINATION ${PROJECT_SOURCE_DIR}/tensor_comprehensions)
+
+add_library(tclib MODULE tclib.cc)
+target_include_directories(tclib PUBLIC ${PROJECT_SOURCE_DIR}/tc)
+target_link_libraries(
+  tclib
+
+  tc_autotuner
+  tc_aten
+
+  ${PYTHON_LIBRARIES}
+)
+
+set_target_properties(tclib PROPERTIES PREFIX "")
+set_target_properties(tclib PROPERTIES SUFFIX ".so")
+set_target_properties(tclib PROPERTIES DEBUG_POSTFIX "")
+
+# "Install" to source_dir/tensor_comprehensions for easy inclusion in python
+# package with setuptools. Without this, setuptools is hell.
+install(TARGETS tclib DESTINATION ${PROJECT_SOURCE_DIR}/tensor_comprehensions)