Fix format

Author: wsmoses

include/tc/core/polyhedral/llvm_jit.h

@@ -34,6 +34,7 @@ class Jit {
   llvm::orc::RTDyldObjectLinkingLayer objectLayer_;
   llvm::orc::IRCompileLayer<decltype(objectLayer_), llvm::orc::SimpleCompiler>
       compileLayer_;
+
  public:
   Jit();
 

src/core/polyhedral/codegen_llvm.cc

@@ -28,8 +28,8 @@
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Transforms/IPO.h"
+#include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Transforms/Tapir/CilkABI.h"
 
 #include "Halide/Halide.h"
@@ -205,6 +205,10 @@ class IslAstExprInterpeter {
   }
 };
 
+DEFINE_bool(llvm_dump_before_opt, false, "Print IR before optimization");
+DEFINE_bool(llvm_dump_after_opt, false, "Print IR after optimization");
+static constexpr int kOptLevel = 3;
+
 class CodeGen_TC : public Halide::Internal::CodeGen_X86 {
  public:
   const isl::pw_multi_aff* iteratorMap_;
@@ -303,81 +307,52 @@ class CodeGen_TC : public Halide::Internal::CodeGen_X86 {
 
     value = sym_get(name);
   }
-public:
-  void optimize_module() {
-    Halide::Internal::debug(3) << "Optimizing module\n";
 
-    if (Halide::Internal::debug::debug_level() >= 3) {
-        #if LLVM_VERSION_MAJOR >= 5
-        module->print(llvm::dbgs(), nullptr, false, true);
-        #else
-        module->dump();
-        #endif
+ public:
+  void optimize_module() {
+    if (FLAGS_llvm_dump_before_opt) {
+      module->print(llvm::dbgs(), nullptr, false, true);
     }
 
-    // We override PassManager::add so that we have an opportunity to
-    // blacklist problematic LLVM passes.
-    class MyFunctionPassManager : public llvm::legacy::FunctionPassManager {
-    public:
-        MyFunctionPassManager(llvm::Module *m) : llvm::legacy::FunctionPassManager(m) {}
-        virtual void add(llvm::Pass *p) override {
-            Halide::Internal::debug(2) << "Adding function pass: " << p->getPassName().str() << "\n";
-            llvm::legacy::FunctionPassManager::add(p);
-        }
-    };
-
-    class MyModulePassManager : public llvm::legacy::PassManager {
-    public:
-        virtual void add(llvm::Pass *p) override {
-            Halide::Internal::debug(2) << "Adding module pass: " << p->getPassName().str() << "\n";
-            llvm::legacy::PassManager::add(p);
-        }
-    };
-
-    MyFunctionPassManager function_pass_manager(module.get());
-    MyModulePassManager module_pass_manager;
+    llvm::legacy::FunctionPassManager functionPassManager(module.get());
+    llvm::legacy::PassManager modulePassManager;
 
-    std::unique_ptr<llvm::TargetMachine> TM = Halide::Internal::make_target_machine(*module);
-    module_pass_manager.add(llvm::createTargetTransformInfoWrapperPass(TM ? TM->getTargetIRAnalysis() : llvm::TargetIRAnalysis()));
-    function_pass_manager.add(llvm::createTargetTransformInfoWrapperPass(TM ? TM->getTargetIRAnalysis() : llvm::TargetIRAnalysis()));
+    std::unique_ptr<llvm::TargetMachine> targetMachine =
+        Halide::Internal::make_target_machine(*module);
+    modulePassManager.add(llvm::createTargetTransformInfoWrapperPass(
+        targetMachine ? targetMachine->getTargetIRAnalysis()
+                      : llvm::TargetIRAnalysis()));
+    functionPassManager.add(llvm::createTargetTransformInfoWrapperPass(
+        targetMachine ? targetMachine->getTargetIRAnalysis()
+                      : llvm::TargetIRAnalysis()));
 
     llvm::PassManagerBuilder b;
-    b.OptLevel = 3;
+    b.OptLevel = kOptLevel;
     b.tapirTarget = new llvm::CilkABI();
-#if LLVM_VERSION_MAJOR >= 5
     b.Inliner = llvm::createFunctionInliningPass(b.OptLevel, 0, false);
-#else
-    b.Inliner = llvm::createFunctionInliningPass(b.OptLevel, 0);
-#endif
     b.LoopVectorize = true;
     b.SLPVectorize = true;
 
-#if LLVM_VERSION_MAJOR >= 5
-    if (TM) {
-        TM->adjustPassManager(b);
+    if (targetMachine) {
+      targetMachine->adjustPassManager(b);
     }
-#endif
 
-    b.populateFunctionPassManager(function_pass_manager);
-    b.populateModulePassManager(module_pass_manager);
+    b.populateFunctionPassManager(functionPassManager);
+    b.populateModulePassManager(modulePassManager);
 
     // Run optimization passes
-    function_pass_manager.doInitialization();
+    functionPassManager.doInitialization();
     for (llvm::Module::iterator i = module->begin(); i != module->end(); i++) {
-        function_pass_manager.run(*i);
-    }
-    function_pass_manager.doFinalization();
-    module_pass_manager.run(*module);
+      functionPassManager.run(*i);
+
+      functionPassManager.doFinalization();
+      modulePassManager.run(*module);
 
-    Halide::Internal::debug(3) << "After LLVM optimizations:\n";
-    if (Halide::Internal::debug::debug_level() >= 2) {
-        #if LLVM_VERSION_MAJOR >= 5
+      if (FLAGS_llvm_dump_after_opt) {
         module->print(llvm::dbgs(), nullptr, false, true);
-        #else
-        module->dump();
-        #endif
+      }
     }
-}
+  }
 };
 
 class LLVMCodegen {
@@ -535,16 +510,17 @@ class LLVMCodegen {
         llvm::BasicBlock::Create(llvmCtx, "loop_latch", function);
     auto* loopExitBB = llvm::BasicBlock::Create(llvmCtx, "loop_exit", function);
 
-    //TODO: integrate query ISL as to whether the relevant loop ought be parallelized
+    // TODO: integrate query ISL as to whether the relevant loop ought be
+    // parallelized
     bool parallel = false;
 
     llvm::Value* SyncRegion = nullptr;
     if (parallel) {
       SyncRegion = halide_cg.get_builder().CreateCall(
-        llvm::Intrinsic::getDeclaration(function->getParent(), llvm::Intrinsic::syncregion_start),
-        {},
-        "syncreg"
-      );
+          llvm::Intrinsic::getDeclaration(
+              function->getParent(), llvm::Intrinsic::syncregion_start),
+          {},
+          "syncreg");
     }
 
     halide_cg.get_builder().CreateBr(headerBB);
@@ -596,8 +572,10 @@ class LLVMCodegen {
       halide_cg.get_builder().SetInsertPoint(loopBodyBB);
 
       if (parallel) {
-        auto* detachedBB = llvm::BasicBlock::Create(llvmCtx, "det.achd", function);
-        halide_cg.get_builder().CreateDetach(detachedBB, loopLatchBB, SyncRegion);
+        auto* detachedBB =
+            llvm::BasicBlock::Create(llvmCtx, "det.achd", function);
+        halide_cg.get_builder().CreateDetach(
+            detachedBB, loopLatchBB, SyncRegion);
         halide_cg.get_builder().SetInsertPoint(detachedBB);
       }
       auto* currentBB = emitAst(node.for_get_body());
@@ -624,9 +602,9 @@ class LLVMCodegen {
     halide_cg.get_builder().SetInsertPoint(loopExitBB);
     halide_cg.sym_pop(node.for_get_iterator().get_id().get_name());
     if (parallel) {
-        auto* syncBB = llvm::BasicBlock::Create(llvmCtx, "synced", function);
-        halide_cg.get_builder().CreateSync(syncBB, SyncRegion);
-        halide_cg.get_builder().SetInsertPoint(syncBB);
+      auto* syncBB = llvm::BasicBlock::Create(llvmCtx, "synced", function);
+      halide_cg.get_builder().CreateSync(syncBB, SyncRegion);
+      halide_cg.get_builder().SetInsertPoint(syncBB);
     }
     return halide_cg.get_builder().GetInsertBlock();
   }
@@ -695,7 +673,8 @@ class LLVMCodegen {
   CodeGen_TC halide_cg;
 };
 
-// Create a list of isl ids to be used as loop iterators when building the AST.
+// Create a list of isl ids to be used as loop iterators when building the
+// AST.
 //
 // Note that this function can be scrapped as ISL can generate some default
 // iterator names.  However, it may come handy for associating extra info with

src/core/polyhedral/llvm_jit.cc

@@ -13,6 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <stdexcept>
+
 #include "tc/core/polyhedral/llvm_jit.h"
 
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
@@ -29,16 +31,55 @@
 
 using namespace llvm;
 
+// Parse through ldconfig to find the path of a particular
+// shared library. This is an unfortunate way to have to
+// find it, but I couldn't immediately find something in
+// imported libraries that would resolve this for us.
+std::string find_library_path(std::string library) {
+  std::string command = "ldconfig -p | grep " + library;
+
+  FILE* fpipe = popen(command.c_str(), "r");
+
+  if (fpipe == nullptr) {
+    throw std::runtime_error("Failed to popen()");
+  }
+
+  std::string output;
+  char buffer[512];
+
+  while (1) {
+    int charactersRead = fread(buffer, 1, sizeof(buffer), fpipe);
+    if (charactersRead == 0)
+      break;
+    output += std::string(buffer, charactersRead);
+  }
+  pclose(fpipe);
+
+  int idx = output.rfind("=> ");
+  if (idx == std::string::npos) {
+    throw std::runtime_error("Failed locate library: " + library);
+  }
+  output = output.substr(idx + 3);
+  if (output.length() > 0 && output[output.length() - 1] == '\n') {
+    output = output.substr(0, output.length() - 1);
+  }
+  return output;
+}
+
 namespace tc {
 
 Jit::Jit()
     : TM_(EngineBuilder().selectTarget()),
       DL_(TM_->createDataLayout()),
       objectLayer_([]() { return std::make_shared<SectionMemoryManager>(); }),
       compileLayer_(objectLayer_, orc::SimpleCompiler(*TM_)) {
-  sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
   std::string err;
-  sys::DynamicLibrary::LoadLibraryPermanently("cilkrts", &err);
+
+  auto path = find_library_path("libcilkrts.so");
+  sys::DynamicLibrary::LoadLibraryPermanently(path.c_str(), &err);
+  if (err != "") {
+    throw std::runtime_error("Failed to find cilkrts: " + err);
+  }
 }
 
 void Jit::codegenScop(
@@ -84,4 +125,4 @@ JITTargetAddress Jit::getSymbolAddress(const std::string Name) {
   return *res;
 }
 
-}
+} // namespace tc

test/test_mapper_llvm.cc

@@ -68,7 +68,7 @@ TEST(LLVMCodegen, MultiStmt) {
  {
    O1(i, j) +=! A(i, j, rk, rl) * B(i, j)
    O2(i, j) = C(i, j) * D(i, j)
-   O3(i, j) = O1(i, j) + O2(i, j) 
+   O3(i, j) = O1(i, j) + O2(i, j)
  }
  )TC";