LLVM  8.0.0svn
Go to the documentation of this file.
1 //===-- ParallelCG.cpp ----------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines functions that can be used for parallel code generation.
11 //
12 //===----------------------------------------------------------------------===//
17 #include "llvm/IR/LLVMContext.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Support/ErrorOr.h"
26 using namespace llvm;
29  function_ref<std::unique_ptr<TargetMachine>()> TMFactory,
31  std::unique_ptr<TargetMachine> TM = TMFactory();
32  legacy::PassManager CodeGenPasses;
33  if (TM->addPassesToEmitFile(CodeGenPasses, OS, nullptr, FileType))
34  report_fatal_error("Failed to setup codegen");
35  CodeGenPasses.run(*M);
36 }
38 std::unique_ptr<Module> llvm::splitCodeGen(
39  std::unique_ptr<Module> M, ArrayRef<llvm::raw_pwrite_stream *> OSs,
41  const std::function<std::unique_ptr<TargetMachine>()> &TMFactory,
42  TargetMachine::CodeGenFileType FileType, bool PreserveLocals) {
43  assert(BCOSs.empty() || BCOSs.size() == OSs.size());
45  if (OSs.size() == 1) {
46  if (!BCOSs.empty())
47  WriteBitcodeToFile(*M, *BCOSs[0]);
48  codegen(M.get(), *OSs[0], TMFactory, FileType);
49  return M;
50  }
52  // Create ThreadPool in nested scope so that threads will be joined
53  // on destruction.
54  {
55  ThreadPool CodegenThreadPool(OSs.size());
56  int ThreadCount = 0;
59  std::move(M), OSs.size(),
60  [&](std::unique_ptr<Module> MPart) {
61  // We want to clone the module in a new context to multi-thread the
62  // codegen. We do it by serializing partition modules to bitcode
63  // (while still on the main thread, in order to avoid data races) and
64  // spinning up new threads which deserialize the partitions into
65  // separate contexts.
66  // FIXME: Provide a more direct way to do this in LLVM.
67  SmallString<0> BC;
68  raw_svector_ostream BCOS(BC);
69  WriteBitcodeToFile(*MPart, BCOS);
71  if (!BCOSs.empty()) {
72  BCOSs[ThreadCount]->write(BC.begin(), BC.size());
73  BCOSs[ThreadCount]->flush();
74  }
76  llvm::raw_pwrite_stream *ThreadOS = OSs[ThreadCount++];
77  // Enqueue the task
78  CodegenThreadPool.async(
79  [TMFactory, FileType, ThreadOS](const SmallString<0> &BC) {
80  LLVMContext Ctx;
82  MemoryBufferRef(StringRef(BC.data(), BC.size()),
83  "<split-module>"),
84  Ctx);
85  if (!MOrErr)
86  report_fatal_error("Failed to read bitcode");
87  std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
89  codegen(MPartInCtx.get(), *ThreadOS, TMFactory, FileType);
90  },
91  // Pass BC using std::move to ensure that it get moved rather than
92  // copied into the thread's context.
93  std::move(BC));
94  },
95  PreserveLocals);
96  }
98  return {};
99 }
static void codegen(Module *M, llvm::raw_pwrite_stream &OS, function_ref< std::unique_ptr< TargetMachine >()> TMFactory, TargetMachine::CodeGenFileType FileType)
Definition: ParallelCG.cpp:28
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
void SplitModule(std::unique_ptr< Module > M, unsigned N, function_ref< void(std::unique_ptr< Module > MPart)> ModuleCallback, bool PreserveLocals=false)
Splits the module M into N linkable partitions.
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:111
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:510
std::unique_ptr< Module > splitCodeGen(std::unique_ptr< Module > M, ArrayRef< raw_pwrite_stream *> OSs, ArrayRef< llvm::raw_pwrite_stream *> BCOSs, const std::function< std::unique_ptr< TargetMachine >()> &TMFactory, TargetMachine::CodeGenFileType FileType=TargetMachine::CGFT_ObjectFile, bool PreserveLocals=false)
Split M into OSs.size() partitions, and generate code for each.
Definition: ParallelCG.cpp:38
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
A ThreadPool for asynchronous parallel execution on a defined number of threads.
Definition: ThreadPool.h:37
PassManager manages ModulePassManagers.
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
Definition: SmallVector.h:129
void WriteBitcodeToFile(const Module &M, raw_ostream &Out, bool ShouldPreserveUseListOrder=false, const ModuleSummaryIndex *Index=nullptr, bool GenerateHash=false, ModuleHash *ModHash=nullptr)
Write the specified module to the specified raw output stream.
size_t size() const
Definition: SmallVector.h:53
bool run(Module &M)
run - Execute all of the passes scheduled for execution.
Module.h This file contains the declarations for the Module class.
reference get()
Returns a reference to the stored T value.
Definition: Error.h:533
Expected< std::unique_ptr< Module > > parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context)
Read the specified bitcode file, returning the module.
pointer data()
Return a pointer to the vector&#39;s buffer, even if empty().
Definition: SmallVector.h:149
Provides ErrorOr<T> smart pointer.
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:341
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
print Print MemDeps of function
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit...
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144