Dlaczego nie można w pełni kompilować argumentów funkcji F # funkcji wyższego rzędu?

Question

Jedną z rzeczy, które uwielbiam w F #, jest prawdziwe słowo kluczowe inline. Jednak, mimo że pozwala pisać funkcje pierwszego rzędu, które wykonują to samo, co wklejone bloki kodu, rzeczy nie są tak różowe dla funkcji wyższego rzędu. Rozważmy

let inline add i = i+1 
let inline check i = if (add i) = 0 then printfn ""  
let inline iter runs f = for i = 0 to runs-1 do f i 
let runs = 100000000 
time(fun()->iter runs check) 1 
time(fun()->for i = 0 to runs-1 do check i) 1 

Wyniki są 244 ms dla iter i 61 ms do kontroli manualnych. Zagłębmy się w ILSpy. Odpowiednią funkcją dla wywołania bezpośredniego jest:

internal static void func@22-12(Microsoft.FSharp.Core.Unit unitVar0) 
{ 
    for (int i = 0; i < 100000000; i++) 
    { 
     if (i + 1 == 0) 
     { 
      Microsoft.FSharp.Core.PrintfFormat<Microsoft.FSharp.Core.Unit, System.IO.TextWriter, Microsoft.FSharp.Core.Unit, Microsoft.FSharp.Core.Unit> format = new Microsoft.FSharp.Core.PrintfFormat<Microsoft.FSharp.Core.Unit, System.IO.TextWriter, Microsoft.FSharp.Core.Unit, Microsoft.FSharp.Core.Unit, Microsoft.FSharp.Core.Unit>(""); 
      Microsoft.FSharp.Core.PrintfModule.PrintFormatLineToTextWriter<Microsoft.FSharp.Core.Unit>(System.Console.Out, format); 
     } 
    } 
} 

Z numerem add. Odpowiednia funkcja iter jest

internal static void func@22-11(Microsoft.FSharp.Core.Unit unitVar0) 
{ 
    for (int i = 0; i < 100000000; i++) 
    { 
     Tests.FunctionInlining.f@315-5(i); 
    } 
} 
internal static void f@315-5(int i) 
{ 
    if (i + 1 == 0) 
    { 
     Microsoft.FSharp.Core.PrintfFormat<Microsoft.FSharp.Core.Unit, System.IO.TextWriter, Microsoft.FSharp.Core.Unit, Microsoft.FSharp.Core.Unit> format = new Microsoft.FSharp.Core.PrintfFormat<Microsoft.FSharp.Core.Unit, System.IO.TextWriter, Microsoft.FSharp.Core.Unit, Microsoft.FSharp.Core.Unit, Microsoft.FSharp.Core.Unit>(""); 
     Microsoft.FSharp.Core.PrintfModule.PrintFormatLineToTextWriter<Microsoft.FSharp.Core.Unit>(System.Console.Out, format); 
     return; 
    } 
} 

I widzimy kara wydajność pochodzi z jednego dodatkowy poziom pośredni. Jak pokazuje test wydajności, ten kierunek nie jest również usuwany przez kompilator JIT. Czy istnieje powód, dla którego funkcje wyższego rzędu nie mogą być w pełni rozwinięte? To jest problem przy pisaniu jądra obliczeniowego.

Mój czas syntezatora (choć nie bardzo istotne tutaj) jest

let inline time func n = 
    func() |> ignore 
    GC.Collect() 
    GC.WaitForPendingFinalizers() 
    let stopwatch = Stopwatch.StartNew() 
    for i = 0 to n-1 do func() |> ignore 
    stopwatch.Stop() 
    printfn "Took %A ms" stopwatch.Elapsed.TotalMilliseconds 

Answer 1

Wystarczy być jasne, F # kompilator inline każdą definicję, które zostały oznaczone jako inline. Chodzi o to, że obecne zachowanie inline nie jest zbyt użyteczne, gdy używa się funkcji inline jako argumentu wyższego rzędu. check może być wstawiony tylko po podaniu argumentu, a więc iter runs check jest traktowany jako iter runs (fun i -> check i). Następnie check dostaje inlined, powodując równowartości

iter runs (fun i -> if (add i) = 0 then printfn "") 

(jak widać w IL, nie ma wezwanie do check w wygenerowanym IL, ale nie jest to wezwanie do syntetycznego f@315-5 ciała do tego lambda , co jest równoważne). iter zostaje również wprowadzony.

Powiedziawszy to, zgadzam się, że obecne zachowanie nie jest tak użyteczne, jak mogłoby być - kompilator może również wstawiać treść lambda do strony wywołania, co byłoby bezpieczne i poprawiłoby wydajność.