为啥这个 F# 代码这么慢？

Posted 2023-02-16

【中文标题】为啥这个 F# 代码这么慢？

【英文标题】：Why is this F# code so slow?为什么这个 F# 代码这么慢？

【发布时间】：2011-08-31 13:05:35

【问题描述】：

C# 和 F# 中的 Levenshtein 实现。对于大约 1500 个字符的两个字符串，C# 版本的速度提高了 10 倍。 C#：69 毫秒，F# 867 毫秒。为什么？据我所知，他们做同样的事情？不管是发布版本还是调试版本。

编辑：如果有人专门来这里寻找“编辑距离”实现，那它就坏了。工作代码是here。

C#：

private static int min3(int a, int b, int c)

   return Math.Min(Math.Min(a, b), c);


public static int EditDistance(string m, string n)

   var d1 = new int[n.Length];
   for (int x = 0; x < d1.Length; x++) d1[x] = x;
   var d0 = new int[n.Length];
   for(int i = 1; i < m.Length; i++)
   
      d0[0] = i;
      var ui = m[i];
      for (int j = 1; j < n.Length; j++ )
      
         d0[j] = 1 + min3(d1[j], d0[j - 1], d1[j - 1] + (ui == n[j] ? -1 : 0));
      
      Array.Copy(d0, d1, d1.Length);
   
   return d0[n.Length - 1];

F#：

let min3(a, b, c) = min a (min b c)

let levenshtein (m:string) (n:string) =
   let d1 = Array.init n.Length id
   let d0 = Array.create n.Length 0
   for i=1 to m.Length-1 do
      d0.[0] <- i
      let ui = m.[i]
      for j=1 to n.Length-1 do
         d0.[j] <- 1 + min3(d1.[j], d0.[j-1], d1.[j-1] + if ui = n.[j] then -1 else 0)
      Array.blit d0 0 d1 0 n.Length
   d0.[n.Length-1]

【问题讨论】：

使用内联的性能差异是多少？

【参考方案1】：

问题在于 min3 函数被编译为使用泛型比较的泛型函数（我认为这仅使用 IComparable，但它实际上更复杂 - 它会使用 F# 类型的结构比较，而且相当复杂的逻辑）。

> let min3(a, b, c) = min a (min b c);;
val min3 : 'a * 'a * 'a -> 'a when 'a : comparison

在 C# 版本中，该函数不是通用的（它只需要 int）。您可以通过添加类型注释来改进 F# 版本（以获得与 C# 中相同的内容）：

let min3(a:int, b, c) = min a (min b c)

...或将min3 设为inline（在这种情况下，使用时将专用于int）：

let inline min3(a, b, c) = min a (min b c);;

对于长度为 300 的随机字符串 str，我得到以下数字：

> levenshtein str ("foo" + str);;
Real: 00:00:03.938, CPU: 00:00:03.900, GC gen0: 275, gen1: 1, gen2: 0
val it : int = 3

> levenshtein_inlined str ("foo" + str);;
Real: 00:00:00.068, CPU: 00:00:00.078, GC gen0: 0, gen1: 0, gen2: 0
val it : int = 3

【讨论】：

为什么 F# 不将 min3 编译为一个接受 int 的函数？它在编译时已经知道足够的类型信息来执行此操作。如果 min3 是 C++ 模板函数，这就是它的工作方式，所以我有点困惑为什么 F# 不这样做。

F# 推断它尽可能通用，例如“对于所有支持比较的 X 类型”。 inline 像 C++ 模板一样工作，它会根据调用站点专门针对 int。

C++ 模板的行为本质上与 F# 的 inline 相同。默认行为不同的原因是因为它建立在运行时处理的 .Net 泛型之上（并且，可以说，对于编写泛型数字代码来说并不是那么好）。然而，在 F# 中使用 C++ 行为会导致代码膨胀，因为 F# 更多地使用泛型。

C++ 模板语义即使在 C++ 中也会导致代码膨胀，并且缺乏一种方便的方法来切换到使用运行时机制来避免这种情况有时会很麻烦。然而，对代码膨胀的恐惧通常是不合理的——通常，C++ 模板运行良好。

@Steve314 ：通过重构所有不使用依赖类型的代码通常也很容易避免这种情况，这样代码就不会因不同的实例化而重复。