llvm dev - Sep 2008 - [LLVMdev] Run-time optimization using profile data

Hello:

I am new to llvm. I am looking for an example somewhere, or a
walkthrough/guide on how to do runtime optimization using llvm. Ideally, I
would like to:

1. Compile the program from C to LLVM or native with LLVM information
embedded in the binary.
2. Run the binary under LLVM's interpreter, and profile the data. I hope
LLVM has support for all this, and I don't have to insert my own
instructions for profiling.
3. A callback that gets called when a function or a basic block gets hot.
Ideally, I would like to transform this basic block and connected ones in
the graph. So ideally, I would like my function to get called if a trace or
a collection of basic blocks gets hot.
4. I would like to do some transformations in the IR. i.e. from LLVM->LLVM
transforms on the aforementioned hot regions/blocks.
5. I would then like to have control over the JIT as well. In the above
LLVM->LLVM transform, I would have placed some "special"
instructions (like
maybe illegal opcodes, or something like that), and once the JIT is about to
translate those, my routine should get called. I will then transform those
instructions into "special" native instructions. 
6. I then want to execute the newly written binary and remove profile
instrumentation, but leave my special native instructions intact.

I would like to know if there is such an example in the LLVM package. If
not, where in the cpp files should I begin hacking to do each of these
steps.

Regards,

-- 
View this message in context:
http://www.nabble.com/Run-time-optimization-using-profile-data-tp19588300p19588300.html
Sent from the LLVM - Dev mailing list archive at Nabble.com.

On Sat, Sep 20, 2008 at 12:12 PM, madiyaan <ahmadsharif at hotmail.com>
wrote:
> Hello:
>
> I am new to llvm. I am looking for an example somewhere, or a
> walkthrough/guide on how to do runtime optimization using llvm. Ideally, I
> would like to:
>
> 1. Compile the program from C to LLVM or native with LLVM information
> embedded in the binary.
> 2. Run the binary under LLVM's interpreter, and profile the data. I
hope
> LLVM has support for all this, and I don't have to insert my own
> instructions for profiling.
That isn't too hard.  It isn't really getting used, but there's some
code for this in the LLVM tree.  See
llvm/lib/Transforms/Instrumentation, and the related runtime support
in llvm/runtime/libprofile.
> 3. A callback that gets called when a function or a basic block gets hot.
> Ideally, I would like to transform this basic block and connected ones in
> the graph. So ideally, I would like my function to get called if a trace or
> a collection of basic blocks gets hot.
>
> 4. I would like to do some transformations in the IR. i.e. from
LLVM->LLVM
> transforms on the aforementioned hot regions/blocks.
There's isn't really any existing code for this, but there isn't
anything fundamentally tricky about it; it's just a matter of writing
code to analyze the profile data and a transformation pass which uses
the data.
> 5. I would then like to have control over the JIT as well. In the above
> LLVM->LLVM transform, I would have placed some "special"
instructions (like
> maybe illegal opcodes, or something like that), and once the JIT is about
to
> translate those, my routine should get called. I will then transform those
> instructions into "special" native instructions.
You want to have the JIT recompile the code as it's running?  The JIT
doesn't currently support that, and it's relatively tricky to write.

Messing with code generation to add platform-specific intrinsics isn't
too hard; you'd need to provide more details to say anything specific,
though.
> 6. I then want to execute the newly written binary and remove profile
> instrumentation, but leave my special native instructions intact.
Stripping out the instrumentation should be a very simple transformation pass.

-Eli

On Sep 20, 2008, at 3:28 PM, Eli Friedman wrote:
>
>> 5. I would then like to have control over the JIT as well. In the  
>> above
>> LLVM->LLVM transform, I would have placed some "special"  
>> instructions (like
>> maybe illegal opcodes, or something like that), and once the JIT is  
>> about to
>> translate those, my routine should get called. I will then  
>> transform those
>> instructions into "special" native instructions.
>
> You want to have the JIT recompile the code as it's running?  The JIT
> doesn't currently support that, and it's relatively tricky to
write.
You are not the first user of JIT that wants something like this.  
There is definite interests in having an alternative call back   
mechanism.  I think there are two issues:

1. Replace the default lazy compilation callback, e.g. see  
X86JITInfo.cpp:
static TargetJITInfo::JITCompilerFn JITCompilerFunction

with a custom one that can run dynamic optimization passes which make  
use of the profile data.

2. Add custom logic to determine when a call instruction is replaced  
with a call to a stub which would in turn invoke the compilation  
callback.

Evan
>
>
> Messing with code generation to add platform-specific intrinsics isn't
> too hard; you'd need to provide more details to say anything specific,
> though.
>
>> 6. I then want to execute the newly written binary and remove profile
>> instrumentation, but leave my special native instructions intact.
>
> Stripping out the instrumentation should be a very simple  
> transformation pass.
>
> -Eli
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev