Warum verursacht F # Inline 11x Leistungsverbesserung

Question

Ich arbeite an einigen schweren CPU gebunden Problem. Ich sehe eine große Leistungsverbesserung, wenn ich das Schlüsselwort inline verwende. einen Wörterbuch aus der Standard-.net-Bibliothek Gang in einem benutzerdefinierten Schlüssel Comparer erstellen siehe Code und Timing Ergebnisse unter

https://gist.github.com/4409734

ohne Schlüsselwort inline auf Eq_cmp

> perf_run 10000000 ;; 
Real: 00:00:11.039, CPU: 00:00:11.029, GC gen0: 771, gen1: 3, gen2: 1 
val it : unit =() 

Inline-Schlüsselwort auf Eq_cmp

perf_run 10000000 ;; 
Real: 00:00:01.319, CPU: 00:00:01.388, GC gen0: 1, gen1: 1, gen2: 1 
val it : unit =() 
> 

Ich bemerkte auch den großen Unterschied in der Menge von Gen 0 GC mit dem INI Code und nicht inline Code.

Könnte jemand erklären, warum es einen so großen Unterschied gibt?

Answer 1

kann ich das Verhalten auf meinem Rechner mit 3-fach Leistungssteigerung reproduzieren nach inline Schlüsselwort hinzufügen.

Das Dekompilieren von zwei Versionen nebeneinander unter ILSpy ergibt fast identischen C# -Code. Der bemerkenswerteste Unterschied ist in zwei Gleichheitstests:

// Version without inline 
bool IEqualityComparer<Program.Pair<a>>.System-Collections-Generic-IEqualityComparer(Program.Pair<a> x, Program.Pair<a> y) 
{ 
    a v@ = x.v@; 
    a v@2 = y.v@; 
    if (LanguagePrimitives.HashCompare.GenericEqualityIntrinsic<a>(v@, v@2)) 
    { 
     a w@ = x.w@; 
     a w@2 = y.w@; 
     return LanguagePrimitives.HashCompare.GenericEqualityIntrinsic<a>(w@, w@2); 
    } 
    return false; 
} 

// Version with inline 
bool IEqualityComparer<Program.Pair<int>>.System-Collections-Generic-IEqualityComparer(Program.Pair<int> x, Program.Pair<int> y) 
{ 
    int v@ = x.v@; 
    int v@2 = y.v@; 
    if (v@ == v@2) 
    { 
     int w@ = x.w@; 
     int w@2 = y.w@; 
     return w@ == w@2; 
    } 
    return false; 
} 

Die allgemeine Gleichheit ist viel weniger effizient als die spezielle Version.

Ich bemerkte auch den großen Unterschied in der Menge von Gen 0 GC mit dem Inline-Code und nicht inline-Code.

Könnte jemand erklären, warum es einen so großen Unterschied gibt?

Wirft man einen Blick auf GenericEqualityIntrinsic Funktion in F# source code:

let rec GenericEqualityIntrinsic (x : 'T) (y : 'T) : bool = 
    fsEqualityComparer.Equals((box x), (box y)) 

Es tut Boxen auf Argumente, die die erhebliche Menge an Müll in Ihrem ersten Beispiel erklärt. Wenn GC zu oft ins Spiel kommt, wird die Berechnung drastisch verlangsamt. Das zweite Beispiel (unter Verwendung von inline) erzeugt fast keinen Müll, wenn Pair struct ist.

Das heißt, es ist das erwartete Verhalten von inline Schlüsselwort, wenn eine spezialisierte Version auf der Aufrufseite verwendet wird. Mein Vorschlag ist immer zu versuchen, Ihren Code auf denselben Benchmarks zu optimieren und zu messen.

Sie könnten an einem sehr ähnlichen Thread Why is this F# code so slow? interessiert sein.

Answer 2

Typ Spezialisierung

Ohne inline, verwenden Sie generischen Vergleich, die sehr ineffizient ist. Mit inline wird die Generizität entfernt und int Vergleich wird direkt verwendet.