mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-05-16 12:05:58 +00:00
a6587cc70d
ThreadSafeModule/ThreadSafeContext are used to manage lifetimes and locking
for LLVMContexts in ORCv2. Prior to this patch contexts were locked as soon
as an associated Module was emitted (to be compiled and linked), and were not
unlocked until the emit call returned. This could lead to deadlocks if
interdependent modules that shared contexts were compiled on different threads:
when, during emission of the first module, the dependence was discovered the
second module (which would provide the required symbol) could not be emitted as
the thread emitting the first module still held the lock.
This patch eliminates this possibility by moving to a finer-grained locking
scheme. Each client holds the module lock only while they are actively operating
on it. To make this finer grained locking simpler/safer to implement this patch
removes the explicit lock method, 'getContextLock', from ThreadSafeModule and
replaces it with a new method, 'withModuleDo', that implicitly locks the context,
calls a user-supplied function object to operate on the Module, then implicitly
unlocks the context before returning the result.
ThreadSafeModule TSM = getModule(...);
size_t NumFunctions = TSM.withModuleDo(
[](Module &M) { // <- context locked before entry to lambda.
return M.size();
});
Existing ORCv2 layers that operate on ThreadSafeModules are updated to use the
new method.
This method is used to introduce Module locking into each of the existing
layers.
llvm-svn: 367686
65 lines
2.0 KiB
C++
65 lines
2.0 KiB
C++
//===-- ThreadSafeModule.cpp - Thread safe Module, Context, and Utilities
|
|
//h-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ExecutionEngine/Orc/ThreadSafeModule.h"
|
|
#include "llvm/Bitcode/BitcodeReader.h"
|
|
#include "llvm/Bitcode/BitcodeWriter.h"
|
|
#include "llvm/Transforms/Utils/Cloning.h"
|
|
|
|
namespace llvm {
|
|
namespace orc {
|
|
|
|
ThreadSafeModule cloneToNewContext(ThreadSafeModule &TSM,
|
|
GVPredicate ShouldCloneDef,
|
|
GVModifier UpdateClonedDefSource) {
|
|
assert(TSM && "Can not clone null module");
|
|
|
|
if (!ShouldCloneDef)
|
|
ShouldCloneDef = [](const GlobalValue &) { return true; };
|
|
|
|
return TSM.withModuleDo([&](Module &M) {
|
|
SmallVector<char, 1> ClonedModuleBuffer;
|
|
|
|
{
|
|
std::set<GlobalValue *> ClonedDefsInSrc;
|
|
ValueToValueMapTy VMap;
|
|
auto Tmp = CloneModule(M, VMap, [&](const GlobalValue *GV) {
|
|
if (ShouldCloneDef(*GV)) {
|
|
ClonedDefsInSrc.insert(const_cast<GlobalValue *>(GV));
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
if (UpdateClonedDefSource)
|
|
for (auto *GV : ClonedDefsInSrc)
|
|
UpdateClonedDefSource(*GV);
|
|
|
|
BitcodeWriter BCWriter(ClonedModuleBuffer);
|
|
|
|
BCWriter.writeModule(*Tmp);
|
|
BCWriter.writeSymtab();
|
|
BCWriter.writeStrtab();
|
|
}
|
|
|
|
MemoryBufferRef ClonedModuleBufferRef(
|
|
StringRef(ClonedModuleBuffer.data(), ClonedModuleBuffer.size()),
|
|
"cloned module buffer");
|
|
ThreadSafeContext NewTSCtx(llvm::make_unique<LLVMContext>());
|
|
|
|
auto ClonedModule = cantFail(
|
|
parseBitcodeFile(ClonedModuleBufferRef, *NewTSCtx.getContext()));
|
|
ClonedModule->setModuleIdentifier(M.getName());
|
|
return ThreadSafeModule(std::move(ClonedModule), std::move(NewTSCtx));
|
|
});
|
|
}
|
|
|
|
} // end namespace orc
|
|
} // end namespace llvm
|