mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 03:02:36 +01:00
efc9f3486a
This patch introduces new APIs to support resource tracking and removal in Orc. It is intended as a thread-safe generalization of the removeModule concept from OrcV1. Clients can now create ResourceTracker objects (using JITDylib::createResourceTracker) to track resources for each MaterializationUnit (code, data, aliases, absolute symbols, etc.) added to the JIT. Every MaterializationUnit will be associated with a ResourceTracker, and ResourceTrackers can be re-used for multiple MaterializationUnits. Each JITDylib has a default ResourceTracker that will be used for MaterializationUnits added to that JITDylib if no ResourceTracker is explicitly specified. Two operations can be performed on ResourceTrackers: transferTo and remove. The transferTo operation transfers tracking of the resources to a different ResourceTracker object, allowing ResourceTrackers to be merged to reduce administrative overhead (the source tracker is invalidated in the process). The remove operation removes all resources associated with a ResourceTracker, including any symbols defined by MaterializationUnits associated with the tracker, and also invalidates the tracker. These operations are thread safe, and should work regardless of the the state of the MaterializationUnits. In the case of resource transfer any existing resources associated with the source tracker will be transferred to the destination tracker, and all future resources for those units will be automatically associated with the destination tracker. In the case of resource removal all already-allocated resources will be deallocated, any if any program representations associated with the tracker have not been compiled yet they will be destroyed. If any program representations are currently being compiled then they will be prevented from completing: their MaterializationResponsibility will return errors on any attempt to update the JIT state. Clients (usually Layer writers) wishing to track resources can implement the ResourceManager API to receive notifications when ResourceTrackers are transferred or removed. The MaterializationResponsibility::withResourceKeyDo method can be used to create associations between the key for a ResourceTracker and an allocated resource in a thread-safe way. RTDyldObjectLinkingLayer and ObjectLinkingLayer are updated to use the ResourceManager API to enable tracking and removal of memory allocated by the JIT linker. The new JITDylib::clear method can be used to trigger removal of every ResourceTracker associated with the JITDylib (note that this will only remove resources for the JITDylib, it does not run static destructors). This patch includes unit tests showing basic usage. A follow-up patch will update the Kaleidoscope and BuildingAJIT tutorial series to OrcV2 and will use this API to release code associated with anonymous expressions.
49 lines
1.5 KiB
C++
49 lines
1.5 KiB
C++
//===--------------- IRCompileLayer.cpp - IR Compiling Layer --------------===//
|
|
//
|
|
// 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/IRCompileLayer.h"
|
|
|
|
namespace llvm {
|
|
namespace orc {
|
|
|
|
IRCompileLayer::IRCompiler::~IRCompiler() {}
|
|
|
|
IRCompileLayer::IRCompileLayer(ExecutionSession &ES, ObjectLayer &BaseLayer,
|
|
std::unique_ptr<IRCompiler> Compile)
|
|
: IRLayer(ES, ManglingOpts), BaseLayer(BaseLayer),
|
|
Compile(std::move(Compile)) {
|
|
ManglingOpts = &this->Compile->getManglingOptions();
|
|
}
|
|
|
|
void IRCompileLayer::setNotifyCompiled(NotifyCompiledFunction NotifyCompiled) {
|
|
std::lock_guard<std::mutex> Lock(IRLayerMutex);
|
|
this->NotifyCompiled = std::move(NotifyCompiled);
|
|
}
|
|
|
|
void IRCompileLayer::emit(std::unique_ptr<MaterializationResponsibility> R,
|
|
ThreadSafeModule TSM) {
|
|
assert(TSM && "Module must not be null");
|
|
|
|
if (auto Obj = TSM.withModuleDo(*Compile)) {
|
|
{
|
|
std::lock_guard<std::mutex> Lock(IRLayerMutex);
|
|
if (NotifyCompiled)
|
|
NotifyCompiled(*R, std::move(TSM));
|
|
else
|
|
TSM = ThreadSafeModule();
|
|
}
|
|
BaseLayer.emit(std::move(R), std::move(*Obj));
|
|
} else {
|
|
R->failMaterialization();
|
|
getExecutionSession().reportError(Obj.takeError());
|
|
}
|
|
}
|
|
|
|
} // End namespace orc.
|
|
} // End namespace llvm.
|