Was bedeutet die 90/10-Regel zur Programmoptimierung?

Laut Wikipedia besagt die 90/10-Regel der Programmoptimierung, dass „90% der Programmausführungszeit für die Ausführung von 10% des Codes aufgewendet werden“ (siehe den zweiten Absatz hier ).

Ich verstehe das wirklich nicht. Was genau bedeutet das? Wie können 90% der Ausführungszeit darauf verwendet werden, nur 10% des Codes auszuführen? Was ist dann mit den anderen 90% des Codes? Wie können sie in nur 10% der Zeit ausgeführt werden?

Hier spielen zwei Grundprinzipien eine Rolle:

• Einige Codes werden viel häufiger ausgeführt als andere. Beispielsweise wird möglicherweise nie ein Fehlerbehandlungscode verwendet. Ein Teil des Codes wird nur ausgeführt, wenn Sie Ihr Programm starten. Anderer Code wird immer wieder ausgeführt, während Ihr Programm ausgeführt wird.
• Manche Codes brauchen viel länger als andere. Beispielsweise wird eine einzelne Zeile, in der eine Abfrage in einer Datenbank ausgeführt oder eine Datei aus dem Internet abgerufen wird, wahrscheinlich länger dauern als Millionen mathematischer Operationen.

Die 90/10-Regel ist nicht wörtlich wahr. Es variiert je nach Programm (und ich bezweifle, dass es überhaupt eine Grundlage für die spezifischen Zahlen 90 und 10 gibt; jemand hat sie wahrscheinlich aus dem Nichts gezogen). Aber der Punkt ist, wenn Sie Ihr Programm schneller ausführen müssen, ist wahrscheinlich nur eine kleine Anzahl von Zeilen von Bedeutung, um dies zu erreichen. Das Erkennen der langsamen Teile Ihrer Software ist häufig der größte Teil der Optimierung.

Dies ist eine wichtige Erkenntnis und bedeutet, dass Entscheidungen, die für einen neuen Entwickler als nicht intuitiv erscheinen, häufig richtig sein können. Zum Beispiel:

• Es gibt viele Codes, für die es sich nicht lohnt, "besser" zu werden , selbst wenn die Dinge dumm und simpel sind. Könnten Sie einen effizienteren Suchalgorithmus für die Anwendung XYZ schreiben? Ja, aber tatsächlich dauert ein einfacher Vergleich jedes Werts eine unbedeutende Zeit, obwohl es Tausende von Werten gibt. Es lohnt sich also einfach nicht. Es kann für neue Entwickler schwierig sein, unnötige Optimierungen zu vermeiden, da in ihrem Studiengang so viel Zeit für das Schreiben des "richtigen" (dh effizientesten) Algorithmus aufgewendet wurde. Aber in der realen Welt, ist der richtige Algorithmus jeder eine , die funktioniert und läuft schnell genug.
• Änderungen, die Ihren Code viel länger und komplexer machen, können immer noch einen Leistungsgewinn bedeuten. In der Anwendung FOO kann es beispielsweise sinnvoll sein, Hunderte von Zeilen neuer Logik hinzuzufügen, um nur einen einzigen Datenbankaufruf zu vermeiden.

Dies ist kein Naturgesetz, sondern eine Faustregel, die aus großer Erfahrung hervorgeht. Sie wird auch als 80/20-Regel bezeichnet und ist immer nur eine grobe Annäherung.

Schleifen, Zweige und andere Flusskontrolle.

An jedem Ort, an dem es ein Wenn gibt, gibt es einen Zweig, der häufiger verwendet wird als der andere Zweig. Daher wird mehr Ausführungszeit für die Ausführung dieses Teils des Programms und nicht des anderen Teils aufgewendet.

An jeder Stelle, an der eine Schleife mehrmals ausgeführt wird, wird mehr Code ausgeführt als der umgebende Code. Dadurch wird mehr Zeit dort verbracht.

Betrachten Sie als Beispiel:

def DoSomeWork():
    for i in range(1000000):
        DoWork(i)
    except WorkExeption:
        print("Oh No!")

Hier print("Oh No!")läuft der Wille immer nur maximal einmal und oft nie, wohingegen der DoWork(i)Wille etwa eine Million Mal vorkommt.

Schleifen.

Ich bin versucht dort anzuhalten! :-)

Betrachten Sie dieses Programm

1. do_something

2. loop 10 times
3.    do_another_thing

4.    loop 5 times
5.        do_more_stuff

Zeile 1 wird einmal ausgeführt, während Zeile 3 zehnmal ausgeführt wird. Jede Zeile der Reihe nach betrachten

1 1   0.8%
2 10  8.3%
3 10  8.3%
4 50 41.3%
5 50 41.3%

Zwei Zeilen machen 83% der Ausführungszeit aus (vorausgesetzt, alle Zeilen benötigen ungefähr die gleiche Ausführungszeit. 40% des Programms benötigen also> 80%.

Bei größeren Beispielen aus der realen Welt steigt dieser Wert, sodass nur eine kleine Anzahl von Zeilen einen Großteil der Laufzeit ausmacht.

Die 90/10-Regel (oder wie manchmal gesagt 80/20) ist eine "Faustregel" - nur annähernd wahr.

Siehe auch Pareto-Prinzip

Da Sie nur nach der Ausführungszeit gefragt haben, könnte dieses Beispiel hilfreich sein:

int main() {
    sleep(90); // approximately 10% of the program.
    // other 90% of the program:
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    return 0;
}

Wenn Sie es etwas ernst meinen, bedeutet dies, dass Sie im echten Code fast immer eine schwere Funktion in einer Schleife aufrufen (statt sleep(90);), während Sie in den restlichen 10% der Zeit einige Berechnungen in einem Durchgang durchführen.

Ein weiteres Beispiel ist die Fehlerbehandlung in einigen HA-Diensten. Jeder hochverfügbare Dienst ist so konzipiert, dass er unter normalen Bedingungen unendlich lange funktioniert . Es arbeitet normalerweise zu 99% in der Zeit, aber gelegentlich führt es im Fehlerfall eine Fehlerbehandlung und -wiederherstellung durch, die möglicherweise noch komplexer als der Dienst selbst ist.

Die Argumentation von 90/10 bedeutet, dass ein kleiner Teil Ihres Codes wiederholt oder häufiger verwendet wird als andere. Dies wird oft verwendet, um vorzuschlagen, dass Sie 90% Ihres Entwicklungs- / Optimierungsaufwands auf diese 10% Ihres Codes konzentrieren sollten.

Denken Sie an ein normales Textverarbeitungsprogramm wie Microsoft Word oder OpenOffice :

• Der Einstellungsdialog wird nicht oft verwendet.
• Die Unterprogramme, die Zeichen zeichnen, werden ständig verwendet.

Dieses Sprichwort wird auch in den Managementwissenschaften verwendet ... Dies ist eine Lektion für das Leben selbst ... Das heißt: Konzentrieren Sie den größten Teil Ihrer Bemühungen, um mehr Ergebnisse zu erzielen.

Stellen Sie sich ein Programm wie dieses vor:

print "H"
print "e"
print "l"
print "l"
print "o"
for i=0 to 1,000,000
    print "How long now?"
next
print "B"
print "y"
print "e"

Beachten Sie, dass es hier 11 Zeilen gibt, von denen 3 die for-Schleife sind. Wie viel Zeit wird für diesen kleinen Teil des Codes aufgewendet? Ein bisschen, während die anderen 8 Zeilen nur ein einzelnes Zeichen drucken. Beachten Sie daher, dass einige Codes zwar kurz sind, Sie jedoch nicht wissen, wie oft sie ausgeführt werden und wie viel Zeit sie in Anspruch nehmen.

Neben dem Schleifen, wie in anderen großartigen Antworten erwähnt, gibt es auch DRY-Prinzipien, die berücksichtigt werden müssen. Gut geschrieben, hat objektorientierter Code viele wiederverwendbare Teile. Die Teile, die per Definition wiederverwendet werden, werden mindestens doppelt so oft verwendet wie etwas, das nur einmal ausgeführt wird. Wenn Sie über viel OO-Code verfügen, können Sie möglicherweise einige Klassen und Methoden mehrmals und einige andere Codeteile nur einmal wiederverwenden.

Wie bereits in anderen Antworten erwähnt, ist es wahrscheinlich besser, den häufig verwendeten Code mit größerem Aufwand zu verbessern, als den Code zu verbessern, der nur ein einziges Mal verwendet wird.

Das ist keine Regel, das ist nur ein Typ, der Wikipedia mit ein paar Zahlen überarbeitet hat und es als Regel bezeichnet hat. Vergleichen Sie mit dem Pareto-Prinzip, das in anderen Zusammenhängen fester verankert ist. Ich würde gerne sehen, welche Untersuchungen zur Genauigkeit dieser "Regel" durchgeführt wurden (falls vorhanden).

Grundsätzlich lautet die Antwort auf Ihre Frage jedoch: Manche Codes werden viel häufiger ausgeführt als andere. Loops sind oft der Grund dafür. Andere Gründe sind zeitaufwändige Anrufe, z. B. zu externen Ressourcen wie Webservices oder Speichermedien.

Es ist eine Neuinterpretation des "Pareto-Prinzips", das besagt, dass "für viele Ereignisse ungefähr 80% der Auswirkungen von 20% der Ursachen stammen", auch bekannt als die 80/20-Regel. Diese Regel bezieht sich hauptsächlich auf die Wirtschaft, daher ist es sinnvoll, sie für die Programmierung neu zu definieren.

Es ist nur ein Muster, das über einen langen Zeitraum beobachtet wurde.

Hier ist ein sehr schönes Video zu Mustern wie diesem und es erklärt auch das Pareto-Prinzip.

https://www.youtube.com/watch?v=fCn8zs912OE&ab_channel=Vsauce