静态成员约束函数的性能

Question

我正在尝试学习F#中的静态成员约束.通过阅读Tomas Petricek的博客文章,我理解编写一个inline"仅使用自己使用静态成员约束编写的操作"的函数将使我的函数正确地适用于满足这些约束的所有数值类型.这个问题表明它的inline工作方式与c ++模板类似,所以我没想到这两个函数之间有任何性能差异:

let MultiplyTyped (A : double[,]) (B : double[,]) =
    let rA, cA = (Array2D.length1 A) - 1, (Array2D.length2 A) - 1
    let cB = (Array2D.length2 B) - 1
    let C = Array2D.zeroCreate<double> (Array2D.length1 A) (Array2D.length2 B)
    for i = 0 to rA do
        for k = 0 to cA do
            for j = 0 to cB do
                C.[i,j] <- C.[i,j] + A.[i,k] * B.[k,j]
    C

let inline MultiplyGeneric (A : 'T[,]) (B : 'T[,]) =
    let rA, cA = Array2D.length1 A - 1, Array2D.length2 A - 1
    let cB = Array2D.length2 B - 1
    let C = Array2D.zeroCreate<'T> (Array2D.length1 A) (Array2D.length2 B)
    for i = 0 to rA do
        for k = 0 to cA do
            for j = 0 to cB do
                C.[i,j] <- C.[i,j] + A.[i,k] * B.[k,j]
    C

然而,要乘以两个1024 x 1024矩阵,MultiplyTyped在我的机器上平均完成2550 ms,而MultiplyGeneric大约需要5150 ms.我原本认为zeroCreate在通用版本中有问题,但是将该行更改为下面的那行并没有什么区别.

let C = Array2D.init<'T> (Array2D.length1 A) (Array2D.length2 B) (fun i j -> LanguagePrimitives.GenericZero)

这里有什么东西让我失去MultiplyGeneric了相同的表现MultiplyTyped吗？或者这是预期的吗？

编辑:我应该提一下,这是VS2010,F#2.0,Win7 64bit,发布版本.平台目标是x64(测试更大的矩阵) - 这有所不同:x86为这两个函数产生类似的结果.

奖金问题:推断的类型MultiplyGeneric如下:

val inline MultiplyGeneric :
   ^T [,] ->  ^T [,] ->  ^T [,]
    when ( ^T or  ^a) : (static member ( + ) :  ^T *  ^a ->  ^T) and
          ^T : (static member ( * ) :  ^T *  ^T ->  ^a)

这种^a类型来自哪里？

编辑2:这是我的测试代码:

let r = new System.Random()
let A = Array2D.init 1024 1024 (fun i j -> r.NextDouble())
let B = Array2D.init 1024 1024 (fun i j -> r.NextDouble())

let test f =
    let sw = System.Diagnostics.Stopwatch.StartNew()
    f() |> ignore
    sw.Stop()
    printfn "%A" sw.ElapsedMilliseconds

for i = 1 to 5 do
    test (fun () -> MultiplyTyped A B)

for i = 1 to 5 do
    test (fun () -> MultiplyGeneric A B)

Answer 1

我想看看你的基准。我没有得到相同的结果（VS 2012 F# 3.0 Win 7 64 位）。

let m = Array2D.init 1024 1024 (fun i j -> float i * float j)

let test f =
  let sw = System.Diagnostics.Stopwatch.StartNew()
  f() |> ignore
  sw.Stop()
  printfn "%A" sw.Elapsed

test (fun () -> MultiplyTyped m m)
> 00:00:09.6013188

test (fun () -> MultiplyGeneric m m)
> 00:00:09.1686885

用Reflector反编译，功能看起来是一样的。

关于你的最后一个问题，推断出限制最少的约束。在这一行

C.[i,j] <- C.[i,j] + A.[i,k] * B.[k,j]

因为 的结果类型A.[i,k] * B.[k,j]未指定，并且立即传递给(+)，因此可能涉及额外的类型。如果您想加强约束，可以将该行替换为

let temp : 'T = A.[i,k] * B.[k,j]
C.[i,j] <- C.[i,j] + temp

这会将签名更改为

val inline MultiplyGeneric :
  A: ^T [,] -> B: ^T [,] ->  ^T [,]
    when  ^T : (static member ( * ) :  ^T *  ^T ->  ^T) and
          ^T : (static member ( + ) :  ^T *  ^T ->  ^T)

编辑

使用您的测试，输出如下：

//多重类型
00:00:09.9904615
00:00:09.5489653
00:00:10.0562346
00:00:09.7023183
00:00:09.5123992
//泛型乘法
00:00:09.1320273
00:00:08.8195283
00:00:08.8523408
00:00:09.2496603
00:00:09.2950196

这是对 ideone 的相同测试（为了保持在时间限制内进行了一些细微的更改：512x512 矩阵和一次测试迭代）。它运行 F# 2.0 并产生类似的结果。