Verlangsamen temporäre Variablen mein Programm?

Question 1

Angenommen, ich habe den folgenden C-Code:

int i = 5;
int j = 10;
int result = i + j;

Wenn ich das viele Male durchlaufe, wäre es schneller zu verwenden int result = 5 + 10? Ich erstelle häufig temporäre Variablen, um meinen Code lesbarer zu machen, zum Beispiel, wenn die beiden Variablen aus einem Array mit einem langen Ausdruck zur Berechnung der Indizes abgerufen wurden. Ist das leistungsmäßig in C schlecht? Was ist mit anderen Sprachen?

Question 2

Ein moderner optimierender Compiler sollte diese Variablen wegoptimieren, zum Beispiel wenn wir das folgende Beispiel in verwenden Gottriegel mit gcc Verwendung der -std=c99 -O3 Flaggen (live sehen):

#include <stdio.h>

void func()
{
  int i = 5;
  int j = 10;
  int result = i + j;

  printf( "%d\n", result ) ;
}

es wird in der folgenden Baugruppe resultieren:

movl    $15, %esi

für die Berechnung von i + jdas ist eine Form von ständige Ausbreitung.

Hinweis, ich habe die hinzugefügt printf damit wir sonst eine Nebenwirkung haben func wäre wegoptimiert worden zu:

func:
  rep ret

Diese Optimierungen sind unter der erlaubt Als-ob-Regel, die nur erfordert, dass der Compiler das beobachtbare Verhalten eines Programms emuliert. Dies wird im Entwurf des C99-Standardabschnitts behandelt 5.1.2.3 Programmausführung was sagt:

In der abstrakten Maschine werden alle Ausdrücke so ausgewertet, wie es die Semantik vorgibt. Eine tatsächliche Implementierung muss einen Teil eines Ausdrucks nicht auswerten, wenn daraus abgeleitet werden kann, dass sein Wert nicht verwendet wird und dass keine erforderlichen Nebeneffekte erzeugt werden (einschließlich solcher, die durch das Aufrufen einer Funktion oder den Zugriff auf ein flüchtiges Objekt verursacht werden).

Siehe auch: Optimierung des C++-Codes: Constant-Folding

Question 3

Dies ist eine einfache Aufgabe, die für einen optimierenden Compiler zu optimieren ist. Es werden alle Variablen gelöscht und ersetzt result mit 15.

Ständiges Einklappen SSA-Formular ist so ziemlich die grundlegendste Optimierung, die es gibt.

Question 4

Das Beispiel, das Sie gegeben haben, ist für einen Compiler einfach zu optimieren. Die Verwendung lokaler Variablen zum Zwischenspeichern von Werten, die aus globalen Strukturen und Arrays gezogen werden, kann die Ausführung Ihres Codes tatsächlich beschleunigen. Wenn Sie beispielsweise etwas aus einer komplexen Struktur innerhalb einer for-Schleife abrufen, bei der der Compiler nicht optimieren kann, und Sie wissen, dass sich der Wert nicht ändert, können die lokalen Variablen einiges an Zeit sparen.

Sie können GCC (auch andere Compiler) verwenden, um den Zwischen-Assemblercode zu generieren und zu sehen, was der Compiler tatsächlich tut.

Hier wird diskutiert, wie die Assembler-Listen aktiviert werden: Verwenden von GCC zum Erstellen einer lesbaren Assemblierung?

Es kann aufschlussreich sein, den generierten Code zu untersuchen und zu sehen, was ein Compiler tatsächlich tut.

Question 5

Während alle möglichen trivialen Unterschiede zum Code das Verhalten des Compilers auf eine Weise stören können, die die Leistung leicht verbessert oder verschlechtert, sollte es im Prinzip keinen Unterschied in der Leistung machen, ob Sie solche temporären Variablen verwenden, solange die Bedeutung des Programms dies nicht ist geändert. Ein guter Compiler sollte in beiden Fällen denselben oder vergleichbaren Code generieren, es sei denn, Sie bauen absichtlich mit ausgeschalteter Optimierung, um Maschinencode zu erhalten, der so nah wie möglich an der Quelle liegt (z. B. für Debugging-Zwecke).

Question 6

Sie leiden unter dem gleichen Problem wie ich, wenn ich versuche zu lernen, was ein Compiler tut – Sie erstellen ein triviales Programm, um das Problem zu demonstrieren, und untersuchen die Assembly-Ausgabe des Compilers, nur um festzustellen, dass der Compiler alles optimiert hat du hast versucht, es zu beseitigen. Möglicherweise finden Sie sogar eine ziemlich komplexe Operation in main(), die auf das Wesentliche reduziert ist:

push "%i"
push 42
call printf 
ret

Ihre ursprüngliche Frage ist nicht “was passiert mit int i = 5; int j = 10...?”, aber “verursachen temporäre Variablen im Allgemeinen eine Laufzeitstrafe?”

Die Antwort ist wahrscheinlich nicht. Aber Sie müssten sich die Assembly-Ausgabe für Ihren speziellen, nicht trivialen Code ansehen. Wenn Ihre CPU viele Register hat, wie ein ARM, dann befinden sich i und j sehr wahrscheinlich in Registern, genau so, als ob diese Register den Rückgabewert einer Funktion direkt speichern würden. Zum Beispiel:

int i = func1();
int j = func2();
int result = i + j;

ist mit ziemlicher Sicherheit genau derselbe Maschinencode wie:

int result = func1() + func2();

Ich schlage vor, dass Sie temporäre Variablen verwenden, wenn sie den Code leichter verständlich und wartungsfreundlicher machen, und wenn Sie wirklich versuchen, eine Schleife zu straffen, werden Sie sowieso in die Assembly-Ausgabe schauen, um herauszufinden, wie Sie so viel Leistung wie möglich optimieren können möglich. Aber opfern Sie die Lesbarkeit und Wartbarkeit nicht für ein paar Nanosekunden, wenn das nicht notwendig ist.