F# 性能问题：编译器在做什么？

Question

引用此代码：F# Static Member Type Constraints

例如，为什么

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

明显慢于

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

通过查看 Reflector，我可以看到编译器以非常不同的方式处理这些中的每一个，但是对于我来说，要解读本质区别的事情太多了。我天真地认为前者会比后者表现更好，因为 gL 是预先计算的，而 G_of 1L 必须计算 100,000 次（至少看起来是这样）。

[编辑]

看起来这可能是 F# 2.0 / .NET 2.0 / 发布模式的错误，请参阅@gradbot 的回答和讨论。

Answer 1

Reflector 显示 test2() 变成了 4 个类，而 test1() 变成了两个类。这仅在调试模式下发生。反射器在发布模式下显示相同的代码（每个类一个）。不幸的是，当我尝试在 C# 中查看源代码并且 IL 真的很长时，Reflector 崩溃了。

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)

快速基准测试。

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)

在 I7 950 @3368Mhz、windows 7 64bit、VS2010 F#2.0 上运行基准测试

x86 调试
test1 8216ms
test2 8237ms

x86 发布
test1 6654ms
test2 6680ms

x64 调试
test1 10304ms
test2 10348ms

x64 版本
test1 8858ms
test2 8977ms

这是完整的代码。

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