[C++ API] Step 11: Swap in the new TC C++ API

This replaces the old implementation with the new refactored
API, updates tests and removes dead code.
Dead files will be removed in the next commit.

This also introduces a stub CPU example that can be run as follows:

build$ make -j 16 && tc/examples/tensordot --tuner_threads=1
--tuner_gen_pop_size=1 --tuner_gen_generations=1 --tuner_gen_number_elites=0
--debug_tuner=1 --gtest_filter="*CPU*"

and prints

Note: Google Test filter = *CPU*
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from TensorDotCPU
[ RUN      ] TensorDotCPU.SimpleAutotune
NYI: CpuBackend::compileWithTcMapper
NYI: CpuTcExecutor::CpuTcExecutor setup RTC
NYI: CpuTuningHarness::warmupOrPrune
NYI: CpuTcExecutor::profileUnchecked
NYI: CpuTcExecutor::profileUnchecked
NYI: CpuTcExecutor::profileUnchecked
NYI: CpuTcExecutor::profileUnchecked
NYI: CpuTcExecutor::profileUnchecked
NYI: CpuTcExecutor::profileUnchecked
NYI: CpuTcExecutor::profileUnchecked
NYI: CpuTcExecutor::profileUnchecked
NYI: CpuTcExecutor::profileUnchecked
NYI: CpuTcExecutor::profileUnchecked
Iteration 0     Jobs(Compiled, Evaluated)/total  (1, 1)/1
(best/median/worst)us: 999999999999/999999999999/999999999999
NYI: CpuBackend::compileWithTcMapper
NYI: CpuTcExecutor::CpuTcExecutor setup RTC
NYI: CpuTcExecutor::profileUnchecked
tensordot size I0: [16, 8, 16, 17, 25], size I1: [16, 16, 2, 17, 25]
ran in: 999999999999us
NYI: CpuBackend::compileWithTcMapper
NYI: CpuTcExecutor::CpuTcExecutor setup RTC
NYI: CpuTcExecutor::profileUnchecked
tensordot size I0: [4, 9, 7, 16, 14], size I1: [4, 7, 3, 16, 14]
ran in: 999999999999us
NYI: CpuBackend::compileWithTcMapper
NYI: CpuTcExecutor::CpuTcExecutor setup RTC
NYI: CpuTcExecutor::profileUnchecked
tensordot size I0: [8, 5, 11, 10, 10], size I1: [8, 11, 16, 10, 10]
ran in: 999999999999us
[       OK ] TensorDotCPU.SimpleAutotune (1269 ms)
[----------] 1 test from TensorDotCPU (1269 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran. (1269 ms total)
[  PASSED  ] 1 test.

Author: nicolasvasilache

README.md

@@ -41,7 +41,7 @@ def tensordot(float(N, C1, C2, H, W) I0,
     O(n, c1, c3, h, w) +=! I0(n, c1, r_c2, h, w) * I1(n, r_c2, c3, h, w)
 }
   )TC";
-  tc::ATenCompilationUnit<tc::CudaTcExecutor> atCompl;
+  tc::ATenCompilationUnit<tc::CudaBackend> atCompl;
   atCompl.define(tc);
 
   // 2. Allocate tensors with random data.

tc/CMakeLists.txt

@@ -5,6 +5,7 @@ add_subdirectory(proto)
 add_subdirectory(version)
 add_subdirectory(core)
 add_subdirectory(autotuner)
+add_subdirectory(aten)
 
 if (WITH_CAFFE2 AND WITH_CUDA)
   add_subdirectory(c2)

tc/aten/CMakeLists.txt

@@ -0,0 +1,26 @@
+################################################################################
+# tc_aten
+#
+# Core CPU library with cross-compilation capabilities linked from
+# tc_aten
+################################################################################
+add_library(
+  tc_aten
+
+  SHARED
+
+  aten_compiler_new_api.cc
+)
+target_link_libraries(
+  tc_aten
+
+  ${HALIDE_LIBRARIES}
+
+  tc_core
+)
+install(
+  TARGETS
+  tc_aten
+
+  DESTINATION lib
+)

tc/autotuner/CMakeLists.txt

@@ -1,18 +1,24 @@
-if (WITH_CUDA)
-  add_library(
-    tc_autotuner
+set(AUTOTUNER_FILES
+  genetic_search.cc
+  parameters.cc
+  utils.cc
+  cpu/autotuner.cc
+)
 
-    SHARED
+set(TC_LIBRARIES ${TC_LIBRARIES} tc_core_cpu)
 
-    genetic_autotuner.cc
-    genetic_autotuner_aten.cc
-    genetic_search.cc
-    genetic_tuning_harness.cc
-    parameters.cc
-    utils.cc)
+if (WITH_CUDA)
+set(AUTOTUNER_FILES ${AUTOTUNER_FILES} cuda/autotuner.cc)
+set(TC_LIBRARIES ${TC_LIBRARIES} tc_cuda)
+endif()
 
-  target_include_directories(tc_autotuner PUBLIC ${PROJECT_SOURCE_DIR}/include)
-  target_link_libraries(tc_autotuner PUBLIC ${ATEN_LIBRARIES} tc_cuda tc_proto)
+add_library(
+  tc_autotuner
+  SHARED
+  ${AUTOTUNER_FILES}
+)
 
-  install(TARGETS tc_autotuner DESTINATION lib)
-endif()
+target_include_directories(tc_autotuner PUBLIC ${PROJECT_SOURCE_DIR}/include)
+target_link_libraries(tc_autotuner PUBLIC ${ATEN_LIBRARIES} ${TC_LIBRARIES})
+
+install(TARGETS tc_autotuner DESTINATION lib)

tc/autotuner/autotuner-inl.h

@@ -54,8 +54,7 @@ TuningHarness<Backend>::TuningHarness(
 template <typename Backend>
 template <typename SearchStrategy>
 void TuningHarness<Backend>::run(SearchStrategy& searchStrategy) {
-  // TODO: kNumGenerations -> iterations
-  for (size_t i = 0; i < searchStrategy.kNumGenerations; ++i) {
+  for (size_t i = 0; i < searchStrategy.numGenerations; ++i) {
     if (not stopRequested_) {
       runOneIteration(searchStrategy, i);
     }

tc/autotuner/genetic_search.cc

@@ -132,13 +132,13 @@ void dropInvalidConfigurations(GeneticSearch::Population& population) {
 
 } // namespace
 
-#define VALIDATE()                                     \
-  CHECK_LT(kNumberElites, kMaxPopulationSize);         \
-  CHECK(kMutationRate >= 0 and kMutationRate <= 100)   \
-      << "the mutation rate (" << kMutationRate        \
-      << ") should be in the [0,100] interval";        \
-  CHECK(kCrossOverRate >= 0 and kCrossOverRate <= 100) \
-      << "the crossover (" << kCrossOverRate           \
+#define VALIDATE()                                   \
+  CHECK_LT(numberElites, maxPopulationSize);         \
+  CHECK(mutationRate >= 0 and mutationRate <= 100)   \
+      << "the mutation rate (" << mutationRate       \
+      << ") should be in the [0,100] interval";      \
+  CHECK(crossOverRate >= 0 and crossOverRate <= 100) \
+      << "the crossover (" << crossOverRate          \
       << ") rate should be in the [0,100] interval";
 
 namespace {
@@ -157,55 +157,34 @@ void restoreRngState(RNG& rng) {
 
 GeneticSearch::GeneticSearch(
     const std::vector<TuningConfiguration>& confs,
-    size_t n,
+    size_t numGenerations,
+    size_t populationSize,
     uint8_t crossOverRate,
     uint8_t mutationRate,
     size_t numberElites)
     : population(),
       lastBestConf(confs[0]),
-      kMaxPopulationSize(n),
-      kCrossOverRate(crossOverRate),
-      kMutationRate(mutationRate),
-      kNumberElites(numberElites),
+      numGenerations(numGenerations),
+      maxPopulationSize(populationSize),
+      crossOverRate(crossOverRate),
+      mutationRate(mutationRate),
+      numberElites(numberElites),
       rng{std::random_device{}()} {
   restoreRngState(rng);
   VALIDATE();
   CHECK(not confs.empty()) << "empty set of predefined configurations";
-  CHECK_LE(confs.size(), n) << "too many predefined configurations";
 
-  population.reserve(confs.size());
-  for (auto& c : confs) {
-    population.push_back(make_unique<CandidateConfiguration>(c));
+  population.reserve(populationSize);
+  size_t size = 0;
+  for (; size < confs.size() && size < maxPopulationSize; ++size) {
+    population.push_back(make_unique<CandidateConfiguration>(confs[size]));
   }
-  if (kMaxPopulationSize - population.size() > 0) {
-    auto oldSize = population.size();
-    for (size_t i = oldSize; i < kMaxPopulationSize; ++i) {
-      population.emplace_back(
-          make_unique<CandidateConfiguration>(*population.front()));
-    }
-    randomizePopulation(population.begin() + oldSize, population.end(), rng);
-  }
-}
-
-GeneticSearch::GeneticSearch(
-    const TuningConfiguration& conf,
-    size_t n,
-    uint8_t crossOverRate,
-    uint8_t mutationRate,
-    size_t numberElites)
-    : population(),
-      lastBestConf(conf),
-      kMaxPopulationSize(n),
-      kCrossOverRate(crossOverRate),
-      kMutationRate(mutationRate),
-      kNumberElites(numberElites),
-      rng{std::random_device{}()} {
-  restoreRngState(rng);
-  VALIDATE();
-  for (size_t i = 0; i < kMaxPopulationSize; ++i) {
-    population.emplace_back(make_unique<CandidateConfiguration>(conf));
+  size_t oldSize = size;
+  for (; size < maxPopulationSize; ++size) {
+    population.emplace_back(
+        make_unique<CandidateConfiguration>(*population.front()));
   }
-  randomizePopulation(population.begin(), population.end(), rng);
+  randomizePopulation(population.begin() + oldSize, population.end(), rng);
 }
 
 TuningConfiguration GeneticSearch::crossover(
@@ -230,7 +209,7 @@ TuningConfiguration GeneticSearch::crossover(
     }
   };
 
-  for (size_t iter = 0; iter < kMutateIterations; ++iter) {
+  for (size_t iter = 0; iter < mutateIterations; ++iter) {
     TuningConfiguration child{a};
     auto params = child.collectParameters();
     for (size_t i = 0; i < params.size(); ++i) {
@@ -249,28 +228,28 @@ TuningConfiguration GeneticSearch::crossover(
 void GeneticSearch::breed() {
   auto accFitness = computeAccumulatedFitness(population);
   Population new_population;
-  new_population.reserve(kMaxPopulationSize);
+  new_population.reserve(maxPopulationSize);
   for (auto& p : population) {
     new_population.push_back(
         make_unique<CandidateConfiguration>(p->configuration));
   }
 
-  auto select = [&]() -> TuningConfiguration& {
+  auto select = [&]() -> const TuningConfiguration& {
     auto limit = std::uniform_real_distribution<double>{}(rng);
     auto lb = std::lower_bound(accFitness.begin(), accFitness.end(), limit);
     return population.at(std::distance(accFitness.begin(), lb))->configuration;
   };
   auto shouldCrossOver = [&]() -> bool {
     /*
-     *Crossover should occur with probability (kCrossOverRate)%
+     *Crossover should occur with probability (crossOverRate)%
      */
     auto dist = std::discrete_distribution<int>{
-        static_cast<double>(100 - kCrossOverRate),
-        static_cast<double>(kCrossOverRate)};
+        static_cast<double>(100 - crossOverRate),
+        static_cast<double>(crossOverRate)};
     return dist(rng);
   };
 
-  while (new_population.size() < kMaxPopulationSize) {
+  while (new_population.size() < maxPopulationSize) {
     if (shouldCrossOver()) {
       auto parent1 = select();
       auto parent2 = select();
@@ -303,9 +282,9 @@ void GeneticSearch::updateParameters() {
   lastBestConf =
       population.size() > 0 ? population.front()->configuration : lastBestConf;
 
-  if (population.size() < kMinCandidatesForBreeding) {
+  if (population.size() < minCandidatesForBreeding) {
     LOG_IF(ERROR, FLAGS_debug_tuner)
-        << population.size() << " out of " << kMaxPopulationSize
+        << population.size() << " out of " << maxPopulationSize
         << " candidates were valid and are not enough to form a new "
            "generation. Likely, most of the tuning runs during this "
            "generation were pruned for lack of parallelism in the "
@@ -314,7 +293,7 @@ void GeneticSearch::updateParameters() {
            "when autotuning a TC operating on small tensors. The next "
            "generation will be randomly initialized.";
     population.resize(0);
-    for (size_t i = 0; i < kMaxPopulationSize; ++i) {
+    for (size_t i = 0; i < maxPopulationSize; ++i) {
       population.emplace_back(
           make_unique<CandidateConfiguration>(lastBestConf));
     }
@@ -325,8 +304,8 @@ void GeneticSearch::updateParameters() {
   }
 
   breed();
-  for (size_t i = kNumberElites; i < population.size(); ++i) {
-    mutate(*population[i], kMutationRate, kMutateIterations, rng);
+  for (size_t i = numberElites; i < population.size(); ++i) {
+    mutate(*population[i], mutationRate, mutateIterations, rng);
   }
 }
 

tc/autotuner/genetic_search.h

@@ -50,33 +50,13 @@ namespace autotune {
 
 class GeneticSearch {
  public:
-  /**
-   * conf is used to determine which are the tunable parameters, the selected
-   * values in conf are ignored and the population is randomized
-   *
-   * n is the population size
-   *
-   * crossoverRate is the probability ([0,100]) that a new candidate is produced
-   * through reproduction
-   *
-   * mutationRate is the probability ([0,100]) that parameters are mutated
-   * (randomly changed) whenever a new generation is created
-   *
-   * numberElites best candidates are preserved
-   * across generations (elitism), number Elites must be less than n
-   */
-  GeneticSearch(
-      const TuningConfiguration& conf,
-      size_t n,
-      uint8_t crossOverRate,
-      uint8_t mutationRate,
-      size_t numberElites);
-
   /**
    * confs are used to seed the first generation, the rest of the population is
    * randomly initialized
    *
-   * n is the population size
+   * numGenerations is the number of generations
+   *
+   * populationSize is the population size
    *
    * crossoverRate is the probability ([0,100]) that a new candidate is produced
    * through reproduction
@@ -85,11 +65,13 @@ class GeneticSearch {
    * (randomly changed) whenever a new generation is created
    *
    * numberElites best candidates are preserved
-   * across generations (elitism), number Elites must be less than n
+   * across generations (elitism), number Elites must be less than
+   * populationSize
    */
   GeneticSearch(
       const std::vector<TuningConfiguration>& confs,
-      size_t n,
+      size_t numGenerations,
+      size_t populationSize,
       uint8_t crossOverRate,
       uint8_t mutationRate,
       size_t numberElites);
@@ -105,17 +87,18 @@ class GeneticSearch {
       TuningConfiguration&) const;
 
  public:
-  static constexpr int kMutateIterations = 1000;
-  static constexpr int kMinCandidatesForBreeding = 3;
+  static constexpr int mutateIterations = 1000;
+  static constexpr int minCandidatesForBreeding = 3;
 
   using Population = std::vector<std::unique_ptr<CandidateConfiguration>>;
 
   Population population;
   TuningConfiguration lastBestConf;
-  const size_t kMaxPopulationSize;
-  const uint8_t kCrossOverRate;
-  const uint8_t kMutationRate;
-  const size_t kNumberElites;
+  const size_t numGenerations;
+  const size_t maxPopulationSize;
+  const uint8_t crossOverRate;
+  const uint8_t mutationRate;
+  const size_t numberElites;
 
   /*
    * c++11 seeding is (apparently) not of the highest quality:

tc/autotuner/genetic_tuning_harness.cc

@@ -176,7 +176,7 @@ TuningConfiguration GeneticTunerHarness::makeTuningConfiguration(
 }
 
 std::vector<size_t> parseGpus() {
-  std::stringstream ss(FLAGS_tuner_gpus);
+  std::stringstream ss(FLAGS_tuner_devices);
   size_t gpu;
   std::vector<size_t> res;
   while (ss >> gpu) {