Optimieren Sie eine "Weile (1)"; in C ++ 0x

Aktualisiert, siehe unten!

Ich habe gehört und gelesen, dass C ++ 0x einem Compiler erlaubt, "Hallo" für das folgende Snippet zu drucken

#include <iostream>

int main() {
  while(1) 
    ;
  std::cout << "Hello" << std::endl;
}

Es hat anscheinend etwas mit Threads und Optimierungsmöglichkeiten zu tun. Es scheint mir, dass dies viele Menschen überraschen kann.

Hat jemand eine gute Erklärung, warum dies notwendig war, um zuzulassen? Als Referenz heißt es im neuesten C ++ 0x-Entwurf unter6.5/5

Eine Schleife, die außerhalb der for-init-Anweisung im Fall einer for-Anweisung

• ruft die E / A-Funktionen der Bibliothek nicht auf und
• greift nicht auf flüchtige Objekte zu oder ändert sie nicht
• führt keine Synchronisationsoperationen (1.10) oder atomaren Operationen (Abschnitt 29) durch

kann von der Implementierung als beendet angenommen werden. [Hinweis: Dies soll Compiler-Transformationen ermöglichen, z. B. das Entfernen leerer Schleifen, auch wenn die Beendigung nicht nachgewiesen werden kann. - Endnote]

Bearbeiten:

Dieser aufschlussreiche Artikel sagt über diesen Standardtext

Leider werden die Wörter "undefiniertes Verhalten" nicht verwendet. Immer wenn der Standard sagt "der Compiler kann P annehmen", wird impliziert, dass ein Programm mit der Eigenschaft nicht-P eine undefinierte Semantik hat.

Ist das richtig und darf der Compiler "Bye" für das obige Programm drucken?

Es gibt hier einen noch aufschlussreicheren Thread , der sich mit einer analogen Änderung von C befasst, die von dem Kerl gestartet wurde, der den oben verlinkten Artikel geschrieben hat. Neben anderen nützlichen Fakten stellen sie eine Lösung vor, die auch für C ++ 0x zu gelten scheint ( Update : Dies funktioniert mit n3225 nicht mehr - siehe unten!)

endless:
  goto endless;

Ein Compiler darf das anscheinend nicht optimieren, weil es keine Schleife ist, sondern ein Sprung. Ein anderer Mann fasst die vorgeschlagene Änderung in C ++ 0x und C201X zusammen

Durch das Schreiben einer Schleife behauptet der Programmierer entweder, dass die Schleife etwas mit sichtbarem Verhalten tut (E / A ausführt, auf flüchtige Objekte zugreift oder Synchronisations- oder Atomoperationen durchführt) oder dass sie schließlich beendet wird. Wenn ich gegen diese Annahme verstoße, indem ich eine Endlosschleife ohne Nebenwirkungen schreibe, lüge ich den Compiler an und das Verhalten meines Programms ist undefiniert. (Wenn ich Glück habe, warnt mich der Compiler möglicherweise davor.) Die Sprache bietet keine Möglichkeit, eine Endlosschleife ohne sichtbares Verhalten auszudrücken (nicht mehr?).

Update am 3.1.2011 mit n3225: Ausschuss hat den Text auf 1.10 / 24 verschoben und sagen

Die Implementierung kann davon ausgehen, dass ein Thread möglicherweise einen der folgenden Schritte ausführt:

• beenden,
• eine Bibliotheks-E / A-Funktion aufrufen,
• auf ein flüchtiges Objekt zugreifen oder es ändern, oder
• Führen Sie eine Synchronisationsoperation oder eine atomare Operation durch.

Der gotoTrick wird nicht mehr funktionieren!

Hat jemand eine gute Erklärung, warum dies notwendig war, um zuzulassen?

Ja, Hans Boehm liefert in N1528 eine Begründung dafür : Warum undefiniertes Verhalten für Endlosschleifen? Obwohl dies ein WG14-Dokument ist, gilt die Begründung auch für C ++ und das Dokument bezieht sich sowohl auf WG14 als auch auf WG21:

Wie N1509 richtig hervorhebt, gibt der aktuelle Entwurf Endlosschleifen in 6.8.5p6 im Wesentlichen undefiniertes Verhalten. Ein Hauptproblem dabei ist, dass Code sich über eine möglicherweise nicht terminierende Schleife bewegen kann. Angenommen, wir haben die folgenden Schleifen, in denen count und count2 globale Variablen sind (oder deren Adresse übernommen wurde) und p eine lokale Variable ist, deren Adresse nicht übernommen wurde:

for (p = q; p != 0; p = p -> next) {
    ++count;
}
for (p = q; p != 0; p = p -> next) {
    ++count2;
}

Könnten diese beiden Schleifen zusammengeführt und durch die folgende Schleife ersetzt werden?

for (p = q; p != 0; p = p -> next) {
        ++count;
        ++count2;
}

Ohne die spezielle Abgabe in 6.8.5p6 für Endlosschleifen wäre dies nicht zulässig: Wenn die erste Schleife nicht beendet wird, weil q auf eine zirkuläre Liste zeigt, schreibt das Original niemals in count2. Somit könnte es parallel mit einem anderen Thread ausgeführt werden, der auf count2 zugreift oder es aktualisiert. Dies ist mit der transformierten Version, die trotz der Endlosschleife auf count2 zugreift, nicht mehr sicher. Somit führt die Transformation möglicherweise ein Datenrennen ein.

In solchen Fällen ist es sehr unwahrscheinlich, dass ein Compiler die Beendigung einer Schleife nachweisen kann. es müsste verstehen, dass q auf eine azyklische Liste verweist, von der ich glaube, dass sie die Fähigkeiten der meisten Mainstream-Compiler übersteigt und ohne vollständige Programminformationen oft unmöglich ist.

Die durch nicht terminierende Schleifen auferlegten Einschränkungen sind eine Einschränkung für die Optimierung von terminierenden Schleifen, für die der Compiler keine Terminierung nachweisen kann, sowie für die Optimierung von tatsächlich nicht terminierenden Schleifen. Die ersteren sind viel häufiger als die letzteren und oft interessanter zu optimieren.

Es gibt eindeutig auch for-Schleifen mit einer Ganzzahlschleifenvariablen, in denen es für einen Compiler schwierig wäre, die Beendigung zu beweisen, und es für den Compiler daher schwierig wäre, Schleifen ohne 6.8.5p6 umzustrukturieren. Sogar so etwas

for (i = 1; i != 15; i += 2)

oder

for (i = 1; i <= 10; i += j)

scheint nicht trivial zu handhaben. (Im ersteren Fall ist eine grundlegende Zahlentheorie erforderlich, um die Beendigung zu beweisen, im letzteren Fall müssen wir etwas über die möglichen Werte von j wissen, um dies zu tun. Das Umschließen für vorzeichenlose ganze Zahlen kann einige dieser Überlegungen weiter erschweren. )

Dieses Problem scheint für fast alle Schleifenumstrukturierungstransformationen zu gelten, einschließlich Compilerparallelisierung und Cache-Optimierungstransformationen, die wahrscheinlich an Bedeutung gewinnen und für numerischen Code bereits häufig wichtig sind. Dies wird wahrscheinlich zu erheblichen Kosten führen, um Endlosschleifen auf möglichst natürliche Weise schreiben zu können, zumal die meisten von uns selten absichtlich Endlosschleifen schreiben.

Der einzige wesentliche Unterschied zu C besteht darin, dass C11 eine Ausnahme für die Steuerung von Ausdrücken darstellt, bei denen es sich um konstante Ausdrücke handelt, die sich von C ++ unterscheiden und Ihr spezifisches Beispiel in C11 genau definieren.

Für mich ist die relevante Begründung:

Dies soll Compiler-Transformationen ermöglichen, z. B. das Entfernen leerer Schleifen, auch wenn die Beendigung nicht nachgewiesen werden kann.

Vermutlich liegt dies daran, dass es schwierig ist , die Terminierung mechanisch zu beweisen, und dass die Unfähigkeit, die Terminierung zu beweisen, Compiler behindert, die andernfalls nützliche Transformationen vornehmen könnten, z. B. das Verschieben nicht abhängiger Operationen von vor der Schleife nach nachher oder umgekehrt, wobei Post-Loop-Operationen in einem Thread ausgeführt werden Die Schleife wird in einer anderen ausgeführt und so weiter. Ohne diese Transformationen kann eine Schleife alle anderen Threads blockieren, während sie darauf warten, dass der eine Thread diese Schleife beendet. (Ich verwende "Thread" lose, um jede Form der Parallelverarbeitung zu bezeichnen, einschließlich separater VLIW-Befehlsströme.)

EDIT: Dummes Beispiel:

while (complicated_condition()) {
    x = complicated_but_externally_invisible_operation(x);
}
complex_io_operation();
cout << "Results:" << endl;
cout << x << endl;

Hier wäre es für einen Thread schneller, dies zu tun, complex_io_operationwährend der andere alle komplexen Berechnungen in der Schleife ausführt. Ohne die von Ihnen angegebene Klausel muss der Compiler jedoch zwei Dinge beweisen, bevor er die Optimierung durchführen kann: 1) die complex_io_operation()nicht von den Ergebnissen der Schleife abhängt, und 2) die Schleife wird beendet . 1) zu beweisen ist ziemlich einfach, 2) zu beweisen ist das Halteproblem. Mit der Klausel kann davon ausgegangen werden, dass die Schleife beendet wird und ein Parallelisierungsgewinn erzielt wird.

Ich stelle mir auch vor, dass die Designer der Ansicht waren, dass die Fälle, in denen Endlosschleifen im Produktionscode auftreten, sehr selten sind und normalerweise ereignisgesteuerte Schleifen sind, die auf irgendeine Weise auf E / A zugreifen. Infolgedessen haben sie den seltenen Fall (Endlosschleifen) zugunsten der Optimierung des häufigeren Falls (nicht unendliche, aber schwer mechanisch zu beweisende nicht unendliche Schleifen) pessimiert.

Dies bedeutet jedoch, dass Endlosschleifen, die in Lernbeispielen verwendet werden, darunter leiden und Fallstricke im Anfängercode auslösen. Ich kann nicht sagen, dass das eine ganz gute Sache ist.

BEARBEITEN: In Bezug auf den aufschlussreichen Artikel, den Sie jetzt verlinken, würde ich sagen, dass "der Compiler X über das Programm annehmen kann" logisch äquivalent zu "wenn das Programm X nicht erfüllt, ist das Verhalten undefiniert" ist. Wir können dies wie folgt zeigen: Angenommen, es gibt ein Programm, das die Eigenschaft X nicht erfüllt. Wo würde das Verhalten dieses Programms definiert? Der Standard definiert das Verhalten nur unter der Annahme, dass die Eigenschaft X wahr ist. Obwohl der Standard das Verhalten nicht explizit als undefiniert deklariert, hat er es durch Auslassen als undefiniert deklariert.

Stellen Sie sich ein ähnliches Argument vor: "Der Compiler kann davon ausgehen, dass eine Variable x höchstens einmal zwischen Sequenzpunkten zugewiesen wird" entspricht "mehr als einmal zwischen Sequenzpunkten zuzuweisen ist undefiniert".

Ich denke, die richtige Interpretation ist die aus Ihrer Bearbeitung: Leere Endlosschleifen sind undefiniertes Verhalten.

Ich würde nicht sagen, dass es ein besonders intuitives Verhalten ist, aber diese Interpretation ist sinnvoller als die alternative, dass der Compiler willkürlich Endlosschleifen ignorieren darf, ohne UB aufzurufen.

Wenn Endlosschleifen UB ist, es bedeutet nur , dass nicht abbrechenden Programme sind nicht aussagekräftig betrachtet: nach C ++ 0x, sie haben keine Semantik.

Das macht auch einen gewissen Sinn. Dies ist ein Sonderfall, bei dem eine Reihe von Nebenwirkungen einfach nicht mehr auftreten (z. B. wird nie etwas zurückgegeben main) und eine Reihe von Compiler-Optimierungen dadurch behindert werden, dass Endlosschleifen beibehalten werden müssen. Zum Beispiel ist das Verschieben von Berechnungen über die Schleife vollkommen gültig, wenn die Schleife keine Nebenwirkungen hat, da die Berechnung schließlich in jedem Fall durchgeführt wird. Wenn die Schleife jedoch niemals beendet wird, können wir den Code nicht sicher neu anordnen, da wir möglicherweise nur ändern, welche Operationen tatsächlich ausgeführt werden, bevor das Programm hängt. Es sei denn, wir behandeln ein Hängeprogramm als UB.

Ich denke, dies entspricht der Art dieser Frage , die auf einen anderen Thread verweist . Durch die Optimierung können gelegentlich leere Schleifen entfernt werden.

Das relevante Problem ist, dass der Compiler Code neu anordnen darf, dessen Nebenwirkungen nicht in Konflikt stehen. Die überraschende Ausführungsreihenfolge könnte auch dann auftreten, wenn der Compiler nicht terminierenden Maschinencode für die Endlosschleife erzeugt.

Ich glaube, das ist der richtige Ansatz. Die Sprachspezifikation definiert Möglichkeiten zum Erzwingen der Ausführungsreihenfolge. Wenn Sie eine Endlosschleife wünschen, die nicht neu angeordnet werden kann, schreiben Sie Folgendes:

volatile int dummy_side_effect;

while (1) {
    dummy_side_effect = 0;
}

printf("Never prints.\n");

Ich denke, das Problem könnte vielleicht am besten wie folgt angegeben werden: "Wenn ein späterer Code nicht von einem früheren Code abhängt und der frühere Code keine Nebenwirkungen auf einen anderen Teil des Systems hat, die Ausgabe des Compilers." kann den späteren Code vor, nach oder mit der Ausführung des ersteren ausführen, selbst wenn der erstere Schleifen enthält, ohne Rücksicht darauf, wann oder ob der erstere Code tatsächlich abgeschlossen werden würde . Beispielsweise könnte der Compiler Folgendes umschreiben:

void testfermat (int n)
{
  int a = 1, b = 1, c = 1;
  während (pow (a, n) + pow (b, n)! = pow (c, n))
  {
    wenn (b> a) a ++; sonst wenn (c> b) {a = 1; b ++}; sonst {a = 1; b = 1; c ++};
  }}
  printf ("Das Ergebnis ist");
  printf ("% d /% d /% d", a, b, c);
}}

wie

void testfermat (int n)
{
  if (fork_is_first_thread ())
  {
    int a = 1, b = 1, c = 1;
    während (pow (a, n) + pow (b, n)! = pow (c, n))
    {
      wenn (b> a) a ++; sonst wenn (c> b) {a = 1; b ++}; sonst {a = 1; b = 1; c ++};
    }}
    signal_other_thread_and_die ();
  }}
  sonst // Zweiter Thread
  {
    printf ("Das Ergebnis ist");
    wait_for_other_thread ();
  }}
  printf ("% d /% d /% d", a, b, c);
}}

Im Allgemeinen nicht unangemessen, obwohl ich mir Sorgen machen könnte, dass:

  int total = 0;
  für (i = 0; num_reps> i; i ++)
  {
    update_progress_bar (i);
    total + = do_something_slow_with_no_side_effects (i);
  }}
  show_result (total);

würde werden

  int total = 0;
  if (fork_is_first_thread ())
  {
    für (i = 0; num_reps> i; i ++)
      total + = do_something_slow_with_no_side_effects (i);
    signal_other_thread_and_die ();
  }}
  sonst
  {
    für (i = 0; num_reps> i; i ++)
      update_progress_bar (i);
    wait_for_other_thread ();
  }}
  show_result (total);

Wenn eine CPU die Berechnungen und eine andere die Fortschrittsbalkenaktualisierungen übernimmt, würde das Umschreiben die Effizienz verbessern. Leider wären die Aktualisierungen des Fortschrittsbalkens weniger nützlich, als sie sein sollten.

Für den Compiler ist es in nicht trivialen Fällen nicht entscheidbar, ob es sich überhaupt um eine Endlosschleife handelt.

In verschiedenen Fällen kann es vorkommen, dass Ihr Optimierer eine bessere Komplexitätsklasse für Ihren Code erreicht (z. B. war es O (n ^ 2) und Sie erhalten nach der Optimierung O (n) oder O (1)).

Die Aufnahme einer solchen Regel, die das Entfernen einer Endlosschleife in den C ++ - Standard nicht zulässt, würde viele Optimierungen unmöglich machen. Und die meisten Leute wollen das nicht. Ich denke, das beantwortet Ihre Frage ganz genau.

Eine andere Sache: Ich habe noch nie ein gültiges Beispiel gesehen, bei dem Sie eine Endlosschleife benötigen, die nichts bewirkt.

Das einzige Beispiel, von dem ich gehört habe, war ein hässlicher Hack, der wirklich anders gelöst werden sollte: Es handelte sich um eingebettete Systeme, bei denen der einzige Weg, einen Reset auszulösen, darin bestand, das Gerät einzufrieren, damit der Watchdog es automatisch neu startet.

Wenn Sie ein gültiges / gutes Beispiel kennen, bei dem Sie eine Endlosschleife benötigen, die nichts bewirkt, sagen Sie es mir bitte.

Ich denke, es ist erwähnenswert, dass Schleifen, die unendlich wären, außer dass sie über nichtflüchtige, nicht synchronisierte Variablen mit anderen Threads interagieren, jetzt mit einem neuen Compiler zu falschem Verhalten führen können.

Mit anderen Worten, machen Sie Ihre Globalen flüchtig - sowie Argumente, die über einen Zeiger / eine Referenz in eine solche Schleife übergeben werden.