[llvm-dev] LLVMContext: Threads and Ownership.

[Lang Hames via llvm-dev]

Hi All,

ORC's new concurrent compilation model generates some interesting lifetime
and thread safety questions around LLVMContext: We need multiple
LLVMContexts (one per module in the simplest case, but at least one per
thread), and the lifetime of each context depends on the execution path of
the JIT'd code. We would like to deallocate contexts once all modules
associated with them have been compiled, but there is no safe or easy way
to check that condition at the moment as LLVMContext does not expose how
many modules are associated with it.

One way to fix this would be to add a mutex to LLVMContext, and expose this
and the module count. Then in the IR-compiling layer of the JIT we could
have something like:

// Compile finished, time to deallocate the module.
// Explicit deletes used for clarity, we would use unique_ptrs in practice.
auto &Ctx = Mod->getContext();
delete Mod;
std::lock_guard<std::mutex> Lock(Ctx->getMutex());
if (Ctx.getNumModules())
  delete Ctx;

Another option would be to invert the ownership model and say that each
Module shares ownership of its LLVMContext. That way LLVMContexts would be
automatically deallocated when the last module using them is destructed
(providing no other shared_ptrs to the context are held elsewhere).

There are other possible approaches (e.g. side tables for the mutex and
module count) but before I spent too much time on it I wanted to see
whether anyone else has encountered these issues or has opinions on
solutions.

Cheers,
Lang.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20180915/efe057f2/attachment.html>