[LLVMdev] Deep JIT specialization

[Nick Lewycky]

On 27 May 2010 15:05, Nicolas Capens <nicolas.capens at gmail.com> wrote:

> Hi Chris,
>
> Thanks for pointing me to that presentation! It helped me come up with a
> strategy that I believe might work:
>
> 1) Use CloneFunction() to make a copy of the original unspecialized (but
> optimized) function.
> 2) Specialize it using a custom function pass which identifies the
> specialization parameters and substitutes them with given run-time
> constants.
>

Use llvm::CloneAndPruneFunctionInfo(). It lets you specify the constant
replacements for values up front and therefore clones less by doing the
constant folding as it goes.

Nick


> 3) Run the function through a FunctionPassManager with some
> post-specialization optimization passes (dead code, etc).
> 4) Use getPointerToFunction() to generate the machine code.
> 5) Call freeMachineCodeForFunction() when I no longer need a specific
> specialization.
>
> I'm not entirely sure yet how to implement some of these steps in practice,
> but does this sound like the right approach or would you suggest something
> else? Can I call eraseFromParent() on the specialized function after step
> 4 or only at 5?
>
> Thank you!
>
> Nicolas
>
>
> On Thu, May 27, 2010 at 6:44 PM, Chris Lattner <clattner at apple.com> wrote:
>
>>
>> On May 27, 2010, at 6:08 AM, Nicolas Capens wrote:
>>
>> > Hi all,
>> >
>> > I'm attempting to use LLVM for run-time code specialization, but I'm
>> facing a performance hurdle. I'm currently performing the specialization
>> during the AST to LLVM IR translation, but unfortunately this leads to
>> relatively slow recompiles as LLVM has to perform all the heavy
>> (optimization) passes over and over again.
>> >
>> > So I was hoping that by first creating unspecialized LLVM IR, optimizing
>> that as much as possible, and then performing the specializations starting
>> from this optimized IR, the recompiles would be significantly faster.
>> Currently the mem2reg and instcombine passes take the majority of
>> compilation time, which could be avoided using "deep" JIT specialization.
>> >
>> > So my question is how do I get started with this? Currently tracking the
>> specialization parameters and caching the generated specialized functions is
>> done outside of LLVM. So I imagine I'll have to somehow inform LLVM of the
>> semi-constant values of the specialization parameters, without losing the
>> original (optimized) IR. Can I add and remove specialized function instances
>> at run-time?
>> >
>>
>> Hi Nicolas,
>>
>> Nate Begeman's "building an efficient JIT" talk about the llvm developer
>> meeting last year (or the year before) is a great place to start looking for
>> this sort of thing.
>>
>> -Chris
>>
>>
>
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20100528/28e074e7/attachment.html>