Add primitive CPU mapper

This commit adds a primitive CPU mapper and updates the tests.
In the current form, the context is not being used to gist and
conditionals on parameters of the form `if (M == 40) { ... } `
are needed.
So this PR also adds the `emitIf` function to generate the proper
LLVM IR and let the tests pass.

Author: nicolasvasilache

tc/core/CMakeLists.txt

@@ -76,6 +76,7 @@ add_library(
 
   polyhedral/codegen_llvm.cc
   polyhedral/llvm_jit.cc
+  polyhedral/cpu/mapped_scop.cc
 )
 target_include_directories(tc_core_cpu PUBLIC ${LLVM_INCLUDE_DIRS})
 target_link_libraries(

tc/core/polyhedral/codegen_llvm.cc

@@ -405,8 +405,8 @@ class LLVMCodegen {
     } else if (auto blockNode = node.as<isl::ast_node_block>()) {
       return emitBlock(blockNode);
     } else {
-      if (node.as<isl::ast_node_if>()) {
-        LOG(FATAL) << "NYI if node: " << node << std::endl;
+      if (auto cond = node.as<isl::ast_node_if>()) {
+        return emitIf(cond);
       } else {
         LOG(FATAL) << "NYI " << node << std::endl;
       }
@@ -445,6 +445,38 @@ class LLVMCodegen {
     return arrTy->getPointerTo();
   }
 
+  llvm::BasicBlock* emitIf(isl::ast_node_if node) {
+    auto* incoming = halide_cg.get_builder().GetInsertBlock();
+    auto* function = incoming->getParent();
+
+    llvm::Value* condVal = halide_cg.codegen(node.get_cond());
+    auto* thenBB = llvm::BasicBlock::Create(llvmCtx, "then", function);
+    // Recursively emit "then" in a new thenBB
+    halide_cg.get_builder().SetInsertPoint(thenBB);
+    auto innerBB = emitAst(node.get_then());
+
+    // outer -> thenBB
+    halide_cg.get_builder().SetInsertPoint(incoming);
+    // outer ---------> if_exit
+    // TODO: When we support "else", go to elseBB instead of exit
+    auto* exit = llvm::BasicBlock::Create(llvmCtx, "if_exit", function);
+    halide_cg.get_builder().CreateCondBr(condVal, thenBB, exit);
+
+    //          then -> if_exit
+    halide_cg.get_builder().SetInsertPoint(innerBB);
+    halide_cg.get_builder().CreateBr(exit);
+
+    // Else is often empty in the absence of full tile extraction
+    if (node.has_else()) {
+      LOG(FATAL) << "NYI: else conditional branch";
+      return halide_cg.get_builder().GetInsertBlock();
+    }
+
+    // Set the insertion point to if_exit
+    halide_cg.get_builder().SetInsertPoint(exit);
+    return halide_cg.get_builder().GetInsertBlock();
+  }
+
   llvm::BasicBlock* emitFor(isl::ast_node_for node) {
     auto* incoming = halide_cg.get_builder().GetInsertBlock();
     auto* function = incoming->getParent();

tc/core/polyhedral/cpu/mapped_scop.cc

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "tc/core/polyhedral/cpu/mapped_scop.h"
+
+#include <algorithm>
+#include <array>
+#include <iostream>
+#include <numeric>
+#include <sstream>
+#include <stdexcept>
+#include <unordered_set>
+
+#include "tc/core/check.h"
+#include "tc/core/flags.h"
+#include "tc/core/functional.h"
+#include "tc/core/polyhedral/codegen_llvm.h"
+#include "tc/core/polyhedral/exceptions.h"
+#include "tc/core/polyhedral/llvm_jit.h"
+#include "tc/core/polyhedral/schedule_transforms.h"
+#include "tc/core/polyhedral/schedule_utils.h"
+#include "tc/core/polyhedral/scop.h"
+
+#include <glog/logging.h>
+
+namespace tc {
+namespace polyhedral {
+
+std::unique_ptr<Jit> MappedScop::codegen(
+    const std::string& specializedName) const {
+  std::unique_ptr<Jit> jit(new Jit());
+  jit->codegenScop(specializedName, *scop_);
+  return jit;
+}
+
+std::unique_ptr<MappedScop> MappedScop::makeSequential(
+    std::unique_ptr<Scop>&& scopUPtr,
+    const CpuMappingOptions& cpuOptions) {
+  using namespace polyhedral::detail;
+
+  const auto& generic = cpuOptions.generic;
+  auto mappedScop = std::unique_ptr<MappedScop>(
+      new MappedScop(std::move(scopUPtr), generic.proto.unroll()));
+  auto& scop = mappedScop->scop_;
+
+  // 1a. Optionally specialize before scheduling...
+  if (generic.proto.fix_parameters_before_scheduling()) {
+    scop->specializeToContext();
+  }
+
+  // 2. Schedule
+  scop = Scop::makeScheduled(*scop, generic.outerScheduleOptions);
+
+  // 3. Tile
+  TC_CHECK_LT(0u, generic.tiling.size())
+      << "Must pass tile vector with >= 1 tile sizes";
+  auto outerBand = scop->tileOuterBand(generic.tiling);
+
+  // 4. Optionally reschedule if point loops need a different strategy than
+  // tile loops
+  if (generic.outerScheduleOptions != generic.intraTileScheduleOptions) {
+    scop->reschedule(outerBand->child({0}), generic.intraTileScheduleOptions);
+    LOG_IF(INFO, FLAGS_debug_tc_mapper)
+        << "After intra-tile rescheduling:" << std::endl
+        << *mappedScop->schedule();
+  }
+
+  // 1b. ...or after rescheduling
+  if (!generic.proto.fix_parameters_before_scheduling()) {
+    scop->specializeToContext();
+  }
+
+  LOG_IF(INFO, FLAGS_debug_tc_mapper)
+      << "After sequential strategy:" << std::endl
+      << *mappedScop->schedule();
+
+  return mappedScop;
+}
+
+} // namespace polyhedral
+} // namespace tc

tc/core/polyhedral/cpu/mapped_scop.h

@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "tc/core/cpu/cpu_mapping_options.h"
+#include "tc/core/polyhedral/llvm_jit.h"
+#include "tc/core/polyhedral/scop.h"
+#include "tc/core/tensor.h"
+#include "tc/external/isl.h"
+
+namespace tc {
+namespace polyhedral {
+
+class MappedScop {
+ private:
+  MappedScop(std::unique_ptr<Scop>&& scop, uint64_t unroll_)
+      : scop_(std::move(scop)), unroll(unroll_) {}
+
+ public:
+  static std::unique_ptr<MappedScop> makeSequential(
+      std::unique_ptr<Scop>&& scopUPtr,
+      const CpuMappingOptions& mappingOptions);
+
+  // Fix the values of the specified parameters in the context
+  // to the corresponding specified values.
+  template <typename T>
+  void fixParameters(const std::unordered_map<std::string, T>& sizes) {
+    scop_->fixParameters(sizes);
+  }
+
+  // Generate code at the current state of transformation provided a
+  // name for the generated function.
+  std::unique_ptr<Jit> codegen(const std::string& specializedName) const;
+
+  // Accessors..
+  // Const accessor to schedule of underlying Scop.
+  inline const detail::ScheduleTree* schedule() const {
+    return scop_->scheduleRoot();
+  }
+  // Reference to underlying scop, no ownership transfer intended.
+  inline const Scop& scop() const {
+    return *scop_;
+  }
+  inline Scop& scop() {
+    return *scop_;
+  }
+
+ private:
+  std::unique_ptr<Scop> scop_;
+
+ public:
+  const uint64_t unroll;
+};
+} // namespace polyhedral
+} // namespace tc