Warum optimieren Compiler Lambdas besser als einfache Funktionen?

Lambda-Funktionsoptimierung

Nicolai Josuttis behauptet in „The C Standard Library“, dass Compiler Lambdas besser optimieren als einfache Funktionen. Dies wirft die Frage auf, warum das so ist.

Inline-Optimierung

Man könnte annehmen, dass die Inline-Optimierung nicht zwischen Lambdas und einfachen Funktionen unterscheiden würde. Der Hauptunterschied liegt jedoch in der Natur von Lambdas als Funktionsobjekte.

Funktionsobjekte vs. Funktionszeiger

Wenn ein Lambda an eine Funktionsvorlage übergeben wird, wird es erstellt eine neue Funktion speziell für dieses Objekt, was zu einem trivial inlinierbaren Funktionsaufruf führt. Im Gegensatz dazu übergeben einfache Funktionen Funktionszeiger, die typischerweise Probleme bei der Inline-Optimierung verursachen. Compiler können solche Aufrufe theoretisch inline, aber nur, wenn die umgebende Funktion ebenfalls inline ist.

Beispiel

Stellen Sie sich eine Funktionsvorlagenzuordnung vor, die einen Iterator und ein Funktionsobjekt als akzeptiert Parameter:

template <typename Iter, typename F>
void map(Iter begin, Iter end, F f) {
    for (; begin != end; ++begin)
        *begin = f(*begin);
}

Aufrufen dieser Vorlage mit a lambda:

int a[] = { 1, 2, 3, 4 };
map(begin(a), end(a), [](int n) { return n * 2; });

Erstellt eine neue Instanziierung der Funktion:

template <>
void map<int*, _some_lambda_type>(int* begin, int* end, _some_lambda_type f) {
    for (; begin != end; ++begin)
        *begin = f.operator()(*begin);
}

Der Compiler kann den Operator() des Lambda problemlos inline aufrufen.

Jedoch wann unter Verwendung eines Funktionszeigers:

int a[] = { 1, 2, 3, 4 };
map(begin(a), end(a), &my_function);

Die resultierende Instanziierung wird zu:

template <>
void map<int*, int (*)(int)>(int* begin, int* end, int (*f)(int)) {
    for (; begin != end; ++begin)
        *begin = f(*begin);
}

Hier zeigt f auf eine andere Adresse für jeden Map-Aufruf, was eine Inline-Optimierung verhindert, es sei denn, der umgebende Map-Aufruf ist ebenfalls inline.

Daher ist der Optimierungsvorteil von Lambdas beruhen auf ihrer Fähigkeit, Funktionsobjekte zu erstellen, die triviale Inline-Funktionen ermöglichen.

Das obige ist der detaillierte Inhalt vonWarum optimieren Compiler Lambdas besser als einfache Funktionen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!