it-swarm.com.de

Was bedeutet die 90/10-Regel der 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 nur für die Ausführung von 10% des Codes aufgewendet werden? Was ist dann mit den anderen 90% des Codes? Wie können sie in nur 10% der Zeit ausgeführt werden?

67
Rakshith Ravi

Hier spielen zwei Grundprinzipien eine Rolle:

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

Die 90/10-Regel ist nicht buchstäblich wahr. Es variiert je nach Programm (und ich bezweifle, dass es überhaupt eine Grundlage für die spezifischen Zahlen 90 und 10 gibt; wahrscheinlich hat jemand sie aus dem Nichts gezogen). Der Punkt ist jedoch: Wenn Ihr Programm schneller ausgeführt werden soll, ist wahrscheinlich nur eine geringe 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 es bedeutet, dass Entscheidungen, die einem neuen Entwickler nicht intuitiv erscheinen, oft richtig sein können. Zum Beispiel:

  • Es gibt viele Codes, für die es sich nicht lohnt, "besser" zu machen, auch wenn die Dinge dumm und simpel gemacht werden. Könnten Sie einen effizienteren Suchalgorithmus für die Anwendung XYZ schreiben? Ja, aber tatsächlich dauert ein einfacher Vergleich jedes Werts trivial lange, obwohl es Tausende von Werten gibt. Es lohnt sich also einfach nicht. Für neue Entwickler kann es 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, der funktioniert und schnell genug läuft.
  • Ä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 Zeilen neuer Logik hinzuzufügen, um einen einzelnen Datenbankaufruf zu vermeiden.
183
user82096

Dies ist kein Naturgesetz, sondern eine Faustregel, die aus einer breiten Erfahrung hervorgeht. Es ist auch als 80/20-Regel bekannt und immer nur eine grobe Annäherung.

Schleifen, Zweige und andere Flusskontrolle.

An jedem Ort mit einem Wenn haben Sie einen Zweig, der häufiger als der andere Zweig genommen wird. Somit wird mehr Zeit für die Ausführung dieses Teils des Programms und nicht des anderen Teils aufgewendet.

An jeder Stelle, an der eine Schleife mehr als einmal ausgeführt wird, befindet sich Code, der mehr als der umgebende Code ausgeführt wird. So wird dort mehr Zeit verbracht.

Betrachten Sie als Beispiel:

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

Hier wird die print("Oh No!") immer nur maximal und oft nie ausgeführt, während die DoWork(i) ungefähr eine Million Mal vorkommt.

20
Caleth

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. Schauen Sie sich nacheinander jede Zeile an

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 dieselbe Laufzeit. 40% des Programms benötigen also> 80%.

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

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

Siehe auch Pareto-Prinzip

16
Nick Keighley

Da Sie nur nach der Ausführungszeit gefragt haben, kann 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 etwas ernster sein möchten, bedeutet dies, dass Sie im realen Code fast immer eine schwere Funktion in einer Schleife aufrufen (anstelle von sleep(90);), während Sie den Rest 10% der Zeit eine einzelne Funktion ausführen. Berechnungen bestehen.

Ein weiteres Beispiel ist die Fehlerbehandlung in einigen HA-Diensten. Jeder hochverfügbare Dienst funktioniert unter normalen Bedingungen nendlich Zeit. Es arbeitet normalerweise 99% der Zeit, führt jedoch gelegentlich im Fehlerfall eine Fehlerbehandlung und -behebung durch, die logisch noch komplexer sein kann als der Dienst selbst.

5
Sergey

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

Denken Sie an einen normalen Textprozessor wie Microsoft Word oder OpenOffice :

  • Der Einstellungsdialog wird nicht viel 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 ... Bedeutung: Konzentrieren Sie die meisten Ihrer Bemühungen dort, wo Sie mehr Ergebnisse erzielen.

3
Lucas

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, wie es hier 11 Zeilen gibt, in denen 3 von 11 die for-Schleife sind, in denen wie viel Zeit für diesen eher kleinen Code aufgewendet wird? Ziemlich lange, während die anderen 8 Zeilen nur ein einzelnes Zeichen drucken. Beachten Sie daher, dass Code zwar kurz sein kann, Ihnen jedoch nicht sagt, wie oft er ausgeführt wird und wie lange er dauern wird.

2
JB King

Es ist eine Neuinterpretation des "Pareto-Prinzips", das besagt, dass "bei vielen Ereignissen etwa 80% der Auswirkungen auf 20% der Ursachen zurückzuführen sind", auch als 80/20-Regel bekannt. Diese Regel wird hauptsächlich auf die Wirtschaft angewendet, daher ist es sinnvoll, sie für die Programmierung zu verwenden.

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

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

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

0
imnota4

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

Aber im Grunde lautet die Antwort auf Ihre Frage: Einige Codes werden viel häufiger ausgeführt als andere. Schleifen sind oft der Grund dafür. Andere Gründe sind zeitaufwändige Anrufe, z. zu externen Ressourcen wie Webdiensten oder Speichermedien.

0
Brad Thomas

Zusätzlich zum Looping, wie in anderen großartigen Antworten erwähnt, müssen auch DRY) Prinzipien berücksichtigt werden. Gut geschriebener, objektorientierter Code enthält viele wiederverwendbare Teile. Die Teile, die per Definition wiederverwendet werden, Verwenden Sie mindestens doppelt so oft wie etwas, das nur einmal ausgeführt wird. Wenn Sie viel OO Code) haben, können Sie möglicherweise einige Klassen und Methoden viele Male und einige andere wiederverwenden Code-Teile nur einmal.

Wie in anderen Antworten erwähnt, ist es wahrscheinlich besser, den Code, der häufiger verwendet wird, besser zu machen, als den Code zu verbessern, der nur einmal verwendet wird.

0