f# learn

Pregunta de rendimiento F#: ¿qué está haciendo el compilador?

Question

Haciendo referencia a este código: F # Restricciones del tipo de miembro estático

¿Por qué es, por ejemplo,

let gL = G_of 1L
[1L..100000L] |> List.map (fun n -> factorize gL n)

significativamente más lento que

[1L..100000L] |> List.map (fun n -> factorize (G_of 1L) n)

Al observar Reflector, puedo ver que el compilador está tratando cada uno de estos de maneras muy diferentes, pero hay mucho que hacer para descifrar la diferencia esencial. Ingenuamente, asumí que el primero funcionaría mejor que el anterior porque gL está precalculado mientras que G_of 1L tiene que calcularse 100.000 veces (al menos así parece).

[ Editar ]

Parece que esto puede ser un error con F # 2.0 / .NET 2.0 / Release-mode, vea la respuesta y discusión de @protbot.

Answer 1

Reflector muestra test2 () convertido en 4 clases mientras test1 () se convierte en dos clases. Esto solo ocurre en el modo de depuración. El reflector muestra un código idéntico (una clase para cada uno) en el modo de lanzamiento. Lamentablemente, Reflector se cuelga cuando intento ver la fuente en C # y el IL es realmente largo.

let test1() =
    let gL = G_of 1L
    [1L..1000000L] |> List.map (fun n -> factorize gL n)

let test2() =
    [1L..1000000L] |> List.map (fun n -> factorize (G_of 1L) n)

Un punto de referencia rápido.

let sw = Stopwatch.StartNew()
test1() |> ignore
sw.Stop()
Console.WriteLine("test1 {0}ms", sw.ElapsedMilliseconds)

let sw2 = Stopwatch.StartNew()
test2() |> ignore
sw2.Stop()
Console.WriteLine("test2 {0}ms", sw2.ElapsedMilliseconds)

Los puntos de referencia funcionaron en I7 950 @ 3368Mhz, Windows 7 64bit, VS2010 F # 2.0

Depuración x86
test1 8216ms
test2 8237ms

Versión x86
test1 6654ms
test2 6680ms

Depuración x64
test1 10304ms
test2 10348ms

Versión x64
test1 8858ms
test2 8977ms

Aquí está el código completo.

open System
open System.Diagnostics

let inline zero_of (target:''a) : ''a = LanguagePrimitives.GenericZero<''a>
let inline one_of (target:''a) : ''a = LanguagePrimitives.GenericOne<''a>
let inline two_of (target:''a) : ''a = one_of(target) + one_of(target)
let inline three_of (target:''a) : ''a = two_of(target) + one_of(target)
let inline negone_of (target:''a) : ''a = zero_of(target) - one_of(target)

let inline any_of (target:''a) (x:int) : ''a =
    let one:''a = one_of target
    let zero:''a = zero_of target
    let xu = if x > 0 then 1 else -1
    let gu:''a = if x > 0 then one else zero-one

    let rec get i g = 
        if i = x then g
        else get (i+xu) (g+gu)
    get 0 zero 

type G<''a> = {
    negone:''a
    zero:''a
    one:''a
    two:''a
    three:''a
    any: int -> ''a
}    

let inline G_of (target:''a) : (G<''a>) = {
    zero = zero_of target
    one = one_of target
    two = two_of target
    three = three_of target
    negone = negone_of target
    any = any_of target
}

let inline factorizeG n = 
    let g = G_of n
    let rec factorize n j flist =  
        if n = g.one then flist 
        elif n % j = g.zero then factorize (n/j) j (j::flist) 
        else factorize n (j + g.one) (flist) 
    factorize n g.two []

let inline factorize (g:G<''a>) n =   //''
    let rec factorize n j flist =  
        if n = g.one then flist 
        elif n % j = g.zero then factorize (n/j) j (j::flist) 
        else factorize n (j + g.one) (flist) 
    factorize n g.two []

let test1() =
    let gL = G_of 1L
    [1L..100000L] |> List.map (fun n -> factorize gL n)

let test2() =
    [1L..100000L] |> List.map (fun n -> factorize (G_of 1L) n)

let sw2 = Stopwatch.StartNew()
test1() |> ignore
sw2.Stop()
Console.WriteLine("test1 {0}ms", sw2.ElapsedMilliseconds)

let sw = Stopwatch.StartNew()
test2() |> ignore
sw.Stop()
Console.WriteLine("test2 {0}ms", sw.ElapsedMilliseconds)

Console.ReadLine() |> ignore