Question

Does such feature exist? Something like Java HotSpot running in server mode, but for .Net applications.

EDIT:
Little more information. I have small application (written in F#) and I have lots of small functions in it. Like this one:

let printable b =
    if b >= ' 'B && b <= '~'B
    then b else '.'B

I had realized that performance in poor, and after profiling I saw that every such function were called millions times. I made them inline and got performance boost (5+ times, may be more).

Ok, nice. Performance is good now. But why didn’t the framework do it? It has enough information about my code and how often a function was called. Why didn’t it inline an function that was called 1M times?

EDIT2:
Sample test to measure difference of an inlined function:

    open System

    let printableByte b =
        if b >= ' 'B && b <= '~'B
        then b else '.'B

    let foo (arr : byte[]) = 
        for i in 0..arr.Length-1 do
            arr.[i] <- printableByte (arr.[i])
        arr.Length / 1000

    let main() =
        let sum = ref 0
        let arr = Array.create 1000000 0uy

        let stopWatch = System.Diagnostics.Stopwatch()
        stopWatch.Start()
        for x in 0..5000 do
            sum := !sum + (foo arr)

        stopWatch.Stop()
        printfn "%d" !sum 
        printfn "total time = %A" stopWatch.ElapsedMilliseconds
        ()

    main()

It runs 19.5 sec when printableByte is not inlined and 13.6 sec when inlined.

EDIT3:
This time difference can be viewed only if compiled for x86 target and run on x64 host. There is no time difference if compiled for “anycpu” or x64.

So, there is no any issue with “small functions” and optimization.

Answer 1

Yes, the CLR does some run-time optimization, as this blog shows.
Note that according to this post, virtual method are not inlined.

neither of these methods was inlined:

• Recursive method
• Virtual method (even if the static type of the receiver variable is sealed)

How is your printable function called in your code? If the F# compiler wraps it in a closure, which it often does, even in cases where you might not expect it at first, then you’ll fall into the “virtual method” case.