IKVM.NET has always had a class granularity JIT. Whenever a type is first "used" the CLR fires the AppDomain.TypeResolve event and at that point the IKVM.NET runtime compiles the Java bytecode to CIL for all of the methods in the class.
I don't recall my exact thought process, but I assume that when I started on IKVM.NET I looked at MethodRental.SwapMethodBody and was scared away by the lack of documentation and the fact that it requires full trust and manually constructing a method body blob.
Later on, I focussed more on static compilation and didn't care too deeply about dynamic performance. So I never revisited this decision. However, recently I have been thinking about dynamic performance, triggered by potential invokedynamic optimizations.
To get reacquainted with MethodRental.SwapMethodBody I wrote a small program that dynamically creates the following class:
|
class Frob {
public Frob(int i) {
Console.WriteLine(i);
}
public static void M(int i) {
Console.WriteLine();
Console.WriteLine(new Frob(i));
}
} |
The code is available here: MethodRentalDemo.cs
When the constructor and the M method are first created, the method body is defined, using MethodBuilder.CreateMethodBody, as a simple trampoline that calls Program.JIT to just-in-time generate the actual CIL for the method.
Here's the managed JIT trampoline CIL code for Frob.M:
|
ldtoken method void Frob::M(int32))
call void Program::JIT(valuetype System.RuntimeMethodHandle)
jmp void Frob::M(int32)
|
The jmp instruction is interesting, it transfers control to a method that takes the same arguments as the current method and passes the current argument values. Here it is used to jump to a new version the same method, where the method body has been replaced with the actual CIL code.
The native code that is generated for the trampoline is:
| |
x86 |
|
x64 |
| |
push ebp
mov ebp,esp
sub esp,8
xor eax,eax
mov dword ptr [ebp-8],eax
mov dword ptr [ebp-4],ecx
lea ecx,[ebp-8]
mov edx,6231A0h
call 680065F0
lea eax,[ebp-8]
push dword ptr [eax]
call FFE39B70
mov ecx,dword ptr [ebp-4]
mov esp,ebp
pop ebp
jmp dword ptr ds:[006231A8h]
|
|
push rbx
sub rsp,20h
mov ebx,ecx
lea rcx,[00257330h]
call FFFFFFFFF35036D0
mov rcx,rax
call 00000000001C84C0
mov ecx,ebx
lea rax,[00247D80h]
add rsp,20h
pop rbx
jmp rax
add rsp,20h
pop rbx
ret
|
(Note that the x64 JIT generates three unreachable instructions at the end. Shown in gray.)
When this code is invoked, it loads the method handle and calls the Program.JIT method. After that returns, it invokes the new method body that the JIT method installed using MethodRental.SwapMethodBody.
When run on the CLR* this all appears to work as you'd hope, but unfortunately that's no guarantee that it will work in the real world. Googling (and experience) suggests that there aren't many** users of MethodRental.SwapMethodBody, so it is quite possible that there are some showstoppers lurking somewhere.
* It does not work on Mono at the moment.
** I found one reference to it in a paper on RubySharp from 2004.