llvm dev - Apr 2016 - MCJIT versus Orc

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?

On Wed, Mar 30, 2016 at 12:19 AM, Justin Bogner <mail at justinbogner.com>
wrote:
> Russell Wallace via llvm-dev <llvm-dev at 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.
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20160330/981f8acc/attachment.html>

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.


On Tue, Mar 29, 2016 at 4:22 PM, Russell Wallace via llvm-dev <
llvm-dev at lists.llvm.org> wrote:
> 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?
>
> On Wed, Mar 30, 2016 at 12:19 AM, Justin Bogner <mail at
justinbogner.com>
> wrote:
>
>> Russell Wallace via llvm-dev <llvm-dev at 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.
>>
>
>
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20160404/4cd4ec25/attachment.html>