llvm dev - Oct 2019 - A question with using ORC RPC for remote JIT-ing.

Background:

We plan to use ORC to JIT compile hot-paths, optimizing them to fully
utilize the currently running architecture.

To do this, we extract the hot-paths' code section (including external
linkages, functions, variables, etc) and embed them into the host program.
These embedded information are then pass to orc to be compiled and executed.

However, the JIT process may fail and may corrupt the host program.
Therefore, we would like to launch a different program to run this JIT
process (including linking symbols that resides in the host program) and
stream the JIT symbol back to the main program for execution.

In short, the main program request the JIT program to compile some IR and
return the JIT symbol back to the main program for execution.

Question:

Is there any tool support for this use-case?
Or, do we have to use our own IPC methods (shared memory) and JIT compile
the IR onto the shared memory, and lookup the JIT symbol in the shared
memory?


Regards,

Choe
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20191011/e2e7f6e3/attachment.html>

There is remote JITing support (
https://llvm.org/docs/tutorial/BuildingAJIT5.html )- though it mostly/only
supports the "from the JITing process, push code to the remote/executing
process" - the first piece of your situation, "from the executing
process,
make a remote request to JIT some code" isn't implemented as far as I
know,
but you could use the same RPC primitives that LLVM/ORC provides to do that.

On Thu, Oct 10, 2019 at 11:35 PM Choe Choon Ho via llvm-dev <
llvm-dev at lists.llvm.org> wrote:
> Background:
>
> We plan to use ORC to JIT compile hot-paths, optimizing them to fully
> utilize the currently running architecture.
>
> To do this, we extract the hot-paths' code section (including external
> linkages, functions, variables, etc) and embed them into the host program.
> These embedded information are then pass to orc to be compiled and
executed.
>
> However, the JIT process may fail and may corrupt the host program.
> Therefore, we would like to launch a different program to run this JIT
> process (including linking symbols that resides in the host program) and
> stream the JIT symbol back to the main program for execution.
>
> In short, the main program request the JIT program to compile some IR and
> return the JIT symbol back to the main program for execution.
>
> Question:
>
> Is there any tool support for this use-case?
> Or, do we have to use our own IPC methods (shared memory) and JIT compile
> the IR onto the shared memory, and lookup the JIT symbol in the shared
> memory?
>
>
> Regards,
>
> Choe
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> https://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/20191011/e6b608da/attachment.html>

Thanks for the head-ups.

On Fri, Oct 11, 2019 at 10:47 PM David Blaikie <dblaikie at gmail.com>
wrote:
> There is remote JITing support (
> https://llvm.org/docs/tutorial/BuildingAJIT5.html )- though it
> mostly/only supports the "from the JITing process, push code to the
> remote/executing process" - the first piece of your situation,
"from the
> executing process, make a remote request to JIT some code" isn't
> implemented as far as I know, but you could use the same RPC primitives
> that LLVM/ORC provides to do that.
>
> On Thu, Oct 10, 2019 at 11:35 PM Choe Choon Ho via llvm-dev <
> llvm-dev at lists.llvm.org> wrote:
>
>> Background:
>>
>> We plan to use ORC to JIT compile hot-paths, optimizing them to fully
>> utilize the currently running architecture.
>>
>> To do this, we extract the hot-paths' code section (including
external
>> linkages, functions, variables, etc) and embed them into the host
program.
>> These embedded information are then pass to orc to be compiled and
executed.
>>
>> However, the JIT process may fail and may corrupt the host program.
>> Therefore, we would like to launch a different program to run this JIT
>> process (including linking symbols that resides in the host program)
and
>> stream the JIT symbol back to the main program for execution.
>>
>> In short, the main program request the JIT program to compile some IR
and
>> return the JIT symbol back to the main program for execution.
>>
>> Question:
>>
>> Is there any tool support for this use-case?
>> Or, do we have to use our own IPC methods (shared memory) and JIT
compile
>> the IR onto the shared memory, and lookup the JIT symbol in the shared
>> memory?
>>
>>
>> Regards,
>>
>> Choe
>> _______________________________________________
>> LLVM Developers mailing list
>> llvm-dev at lists.llvm.org
>> https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
>>
>
-- 
*Choe Choon Ho*
Engineer R&D | CoE
*M*: (60) 12-538 8203
ViTrox <http://www.vitrox.com/> l Facebook
<https://www.facebook.com/ViTroxCorp> l Linkedln
<https://www.linkedin.com/company/vitrox>
*Integrity . Accountability . Courage . Trust & Respect . Gratitude &
Care*
How is my service? Please tell us. Log your feedback/compliments here. Click
Here <http://www.vitrox.com/survey_form/form_view.php?person_id=NzM5>

*Disclaimer: Private & Confidential. This message (including any
attachment) contains confidential information intended for a specific
individual and purpose, and is protected by law. If you are not the
intended recipient, you should delete this message. You must not, directly
or indirectly, use, disclose, distribute, print, copy any part of this
message, or take any action based on it.*
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20191012/b6ab3cd3/attachment.html>