MCJIT versus Orc

When writing a JIT compiler using LLVM, as I understand it, you can use two alternative APIs, MCJIT and Orc. The latter offers lazy compilation. Would it be accurate to say that if you want eager compilation - always compile an entire module upfront - you should use MCJIT?

Russell Wallace via llvm-dev <llvm-dev@lists.llvm.org> writes:

When writing a JIT compiler using LLVM, as I understand it, you can use two
alternative APIs, MCJIT and Orc. The latter offers lazy compilation. Would
it be accurate to say that if you want eager compilation - always compile
an entire module upfront - you should use MCJIT?

+lang.

My understanding is that Orc is strictly more flexible than MCJIT. You
can, in fact, exactly implement the MCJIT API using the Orc APIs.

I think the general advice is that MCJIT's a bit more mature and stable,
but you probably want Orc in new code unless you really need that
maturity.

Right, but is there any known use case where Orc’s flexibility allows something to be done that couldn’t be with MCJIT, apart from lazy compilation?

Hi Russell,

Apologies for the delayed reply.

Orc’s current advantages over MCJIT are:

(1) Built-in support for lazy compilation.
(2) Cleaner support for multi-module management, including un-loading modules.
(3) Much better memory management (depending on use-case, can consume far less memory for JIT’d code).

I expect Orc to gain further advantages over MCJIT in the future too.

I’d recommend using Orc rather than MCJIT.

  • Lang.