Por que esse código F # é tão lento?

127

Uma implementação de Levenshtein em C # e F #. A versão C # é 10 vezes mais rápida para duas seqüências de caracteres de cerca de 1500 caracteres. C #: 69 ms, F # 867 ms. Por quê? Até onde eu sei, eles fazem exatamente a mesma coisa? Não importa se é uma versão ou compilação de depuração.

EDIT: Se alguém vier aqui procurando especificamente pela implementação da Distância de Edição, ela estará corrompida. O código de trabalho está aqui .

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]
Robert Jeppesen
fonte
7
Qual é a diferença de desempenho usando o inline?
gradbot

Respostas:

202

O problema é que a min3função é compilada como uma função genérica que usa comparação genérica (eu pensei que isso usa apenas IComparable, mas na verdade é mais complicado - usaria comparação estrutural para tipos de F # e é uma lógica bastante complexa).

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

Na versão C #, a função não é genérica (é necessária apenas int). Você pode melhorar a versão do F # adicionando anotações de tipo (para obter a mesma coisa que em C #):

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

... ou fazendo min3como inline(nesse caso, ele será especializado intquando usado):

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

Para uma sequência aleatória strde comprimento 300, recebo os seguintes números:

> 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
Tomas Petricek
fonte
1
Por que o F # não compila min3 como uma função que leva int? Ele já conhece informações de tipo suficientes no momento da compilação para fazer isso. É assim que funcionaria se min3 fosse uma função de modelo C ++, então estou um pouco confuso sobre o motivo pelo qual o F # não faz isso.
Sashang
42
O F # infere que seja o mais genérico possível, por exemplo "para todos os tipos X que suportam comparação". inlinefunciona como um modelo C ++, que seria especializado com intbase no site de chamada.
27711 Brian
13
Modelos C ++ se comportam essencialmente como F # 's inline. A razão pela qual o comportamento padrão é diferente é porque ele se baseia em genéricos .Net que são manipulados pelo tempo de execução (e, sem dúvida, não são tão bons para escrever código numérico genérico). No entanto, o uso do comportamento C ++ no F # levaria ao inchaço do código, porque o F # usa muito mais os genéricos.
Tomas Petricek
4
A semântica do modelo C ++ pode levar ao inchaço do código, mesmo em C ++, e à falta de uma maneira conveniente de mudar para o uso de um mecanismo de tempo de execução para evitar que isso seja um problema às vezes. No entanto, o medo do inchaço do código é normalmente irracional - geralmente, os modelos C ++ funcionam bem.
Steve314
@ Steve314: Também geralmente é fácil evitar a refatoração de todo o código que não usa um tipo dependente, para que o código não seja duplicado por instâncias diferentes.
Jarjarjarn 13/04