Warum explodiert die p99-Latenz lange vor 100 % CPU?
Die Warteschlangen-Rechnung für 1, 2 und 16 Kerne, was Lastspitzen mit ihr machen, unsere Postgres-Messung und dieselbe Kurve in vier Designs, die du öffnen kannst.
Kurze Antwort: Eine Anfrage wartet immer dann, wenn in dem Moment, in dem sie ankommt, alle Kerne beschäftigt sind, und diese Wartezeit wächst mit 1 / (1 − Auslastung), nicht mit der Auslastung. Auf einem Kern hat eine Anfrage, die 10 ms Arbeit braucht, ein p99 von 92 ms bei 50 % CPU, 230 ms bei 80 % und 921 ms bei 95 %, während der CPU-Graph noch Luft zeigt.
Mehr Kerne schieben den Knick nach rechts und machen ihn schärfer; stoßweiser Traffic schiebt ihn nach links. Wir haben es an einem echten Postgres gesehen: p99 war 3,5 ms bei 60 % CPU, 12,6 ms bei 88 % und 21 ms bei 94 %. Plane kleine Maschinen für 60–70 %, und rechne eine Flotte kleiner Maschinen als kleine Maschinen.
Ein CPU-Graph ist ein Durchschnitt über eine Minute. Eine Anfrage trifft nicht auf den Durchschnitt: Sie trifft die Maschine in der einen Millisekunde, in der sie ankommt. Bei 80 % CPU ist die Maschine ein Fünftel der Zeit im Leerlauf und den Rest beschäftigt, und eine Anfrage, die sie beschäftigt antrifft, wartet auf die Arbeit vor ihr. Der Durchsatz zeigt das nicht (alles wird noch bedient), der Mittelwert zeigt es kaum, und p99, die Latenz der unglücklichsten Anfrage von hundert, zeigt es zuerst.
Die Rechnung für einen Kern
Auslastung ist Ankunftsrate mal Arbeit pro Anfrage: 80 Anfragen pro Sekunde mit je 10 ms halten einen Kern 80 % der Zeit beschäftigt. Wenn Anfragen zu zufälligen Zeitpunkten ankommen (unabhängige Nutzer tun das) und ihre Arbeit so um ihren Mittelwert schwankt wie bei einer Exponentialverteilung, liefert die Warteschlangentheorie zwei kurze Formeln für einen Kern. Mit S als mittlerer Arbeit pro Anfrage und ρ als Auslastung:
mean response time = S / (1 − ρ)
p99 response time = ln(100) × S / (1 − ρ) ≈ 4.6 × S / (1 − ρ)
Die 100 % spielen in ihnen keine besondere Rolle. Es zählt der Leerlaufanteil, 1 − ρ, und jede Halbierung des Leerlaufanteils verdoppelt die Latenz: von 50 % auf 75 % CPU, von 75 % auf 87,5 %, von 87,5 % auf 93,75 %. Die erste Verdopplung braucht 25 Prozentpunkte CPU, die dritte sechs. Auf einem Dashboard sieht das aus wie eine Wand; in der Formel ist es durchgehend dieselbe Kurve.
Mehr Kerne verschieben den Knick, sie beseitigen ihn nicht
Mit mehreren Kernen wartet eine Anfrage nur, wenn alle beschäftigt sind, und das ist seltener. Bei 70 % Last passiert das auf einem Kern 70 % der Anfragen, auf zwei Kernen 58 % und auf sechzehn 13 % (Erlangs Formel für eine Warteschlange mit mehreren Bedienern). Die Tabelle zeigt das p99 derselben Anfrage von 10 ms:
| CPU-Auslastung | 1 Kern | 2 Kerne | 16 Kerne |
|---|---|---|---|
| 50 % | 92 ms | 57 ms | 46 ms |
| 70 % | 154 ms | 83 ms | 46 ms |
| 80 % | 230 ms | 119 ms | 47 ms |
| 90 % | 461 ms | 233 ms | 53 ms |
| 95 % | 921 ms | 463 ms | 72 ms |
Zwei Dinge lassen sich daraus ablesen. Eine große Maschine kann viel heißer laufen als eine kleine, bevor sich der Tail bewegt: Sechzehn Kerne bei 90 % stehen besser da als ein Kern bei 50 %. Und die große Maschine warnt weniger: Ihr p99 sieht bei 85 % perfekt aus, und die zehn Punkte von dort bis 95 % fügen mehr Latenz hinzu als die ersten 85.
Lastspitzen zählen so viel wie der Durchschnitt
Die Formeln oben setzen zufällige Ankünfte und schwankende Arbeit voraus. Kingmans Näherung für einen Kern sagt, was passiert, wenn eins von beidem anders ist:
mean wait ≈ ρ / (1 − ρ) × (Ca² + Cs²) / 2 × S
Ca und Cs sind die Schwankung der Abstände zwischen den Ankünften und die der Arbeit pro Anfrage (Standardabweichung geteilt durch Mittelwert; 1 für zufällige Ankünfte, 0 für ein Metronom). Schwankung vervielfacht die Wartezeit. Gleichmäßig verteilte Ankünfte halbieren sie; gehäufte Ankünfte (ein Cronjob zur vollen Stunde, ein Client, der es erneut versucht, eine Seite, die zwanzig Aufrufe auf einmal abfeuert) haben ein Ca weit über 1 und vervielfachen sie. Dasselbe gilt für die Arbeit: Ein langsamer Endpunkt unter schnellen erhöht Cs für alle, die hinter ihm warten.
Eine Messung: Postgres auf 2 vCPU
Wir haben ein Postgres auf einer Cloud-VM mit 2 vCPU unter einer Open-Loop-Last in Stufen von 60 Sekunden gemessen, einmal mit zufälligen Ankünften und einmal mit gleichmäßig verteilten. Der vollständige Aufbau und alle Stufen stehen in Wie viele Anfragen pro Sekunde schafft ein Postgres?; das hier sind sieben ihrer zehn Stufen:
| Angebotene Anfragen/s | DB-CPU (zufällig) | p99 zufällig | DB-CPU (gleichmäßig) | p99 gleichmäßig |
|---|---|---|---|---|
| 640 | 9 % | 1,4 ms | 8 % | 1,1 ms |
| 3.200 | 49 % | 2,5 ms | 35 % | 1,1 ms |
| 4.480 | 70 % | 5,7 ms | 58 % | 1,6 ms |
| 5.120 | 80 % | 7,3 ms | 73 % | 3,3 ms |
| 5.440 | 88 % | 12,6 ms | 83 % | 4,2 ms |
| 5.760 | 94 % | 21,0 ms | 91 % | 6,0 ms |
| 6.080 | 99 % | 1.966 ms | 99 % | 1.572 ms |
Mit zufälligen Ankünften lag p99 bei 70 % CPU beim Vierfachen seines Leerlaufwerts und bei 94 % beim Fünfzehnfachen, und dabei wurde jede Anfrage noch bedient. Ab halber Last ergaben dieselben Anfragen pro Sekunde mit gleichmäßig verteilten Ankünften ein zwei- bis viermal niedrigeres p99: die Richtung, die Kingmans Formel angibt. Jenseits der Grenze leert sich die Warteschlange nicht mehr, und die Latenz hängt nur noch davon ab, wie lange die Überlast dauert.
Dieselbe Kurve im Live-Modell
Vier Designs, die du in Stackrig öffnen kannst, jedes ein Dienst, dessen Anfragen im Mittel 10 ms CPU brauchen: ein kleiner Server mit 2 Kernen; acht dieser kleinen Server ohne etwas davor, sodass jede Anfrage einen zufällig gewählten Server erreicht; dieselben acht hinter einem Load Balancer, der die Anfragen reihum verteilt; und ein großer Server mit 16 Kernen (AWS c7g.large und c7g.4xlarge, bei denen eine vCPU ein ganzer Kern ist). Acht kleine Server haben dieselben sechzehn Kerne wie der große, zum selben Preis; der Load Balancer kostet extra. Jedes Design läuft bei 1× Traffic mit 50 % CPU; der Traffic-Regler auf 1,4×, 1,6×, 1,8× und 1,9× liefert die anderen Zeilen.
| CPU-Auslastung | 1 kleiner Server | 8 kleine Server, zufällig gewählt | 8 kleine Server hinter einem Load Balancer | 1 großer Server |
|---|---|---|---|---|
| 50 % | etwa 60 ms | etwa 60 ms | etwa 55 ms | etwa 50 ms |
| 70 % | etwa 85 ms | etwa 85 ms | etwa 65 ms | etwa 50 ms |
| 80 % | etwa 125 ms | etwa 125 ms | etwa 85 ms | etwa 50 ms |
| 90 % | etwa 230 ms | etwa 230 ms | etwa 150 ms | etwa 50 ms |
| 95 % | etwa 460 ms | etwa 460 ms | etwa 270 ms | etwa 75 ms |
Die beiden mittleren Spalten sind die, die du dir merken solltest. Eine Anfrage, die zufällig einen von acht kleinen Servern erreicht, findet dasselbe vor wie bei einem einzelnen kleinen Server: Jeder Server hat seine eigene Warteschlange, und eine Anfrage, die an einem beschäftigten Server wartet, kann keinen freien Kern auf dem Server daneben nutzen. Ein Load Balancer, der die Anfragen reihum verteilt, sorgt bei jedem Server für gleichmäßigere Ankünfte, und der Tail ist bei 90 % CPU etwa ein Drittel niedriger. Er ist immer noch etwa dreimal so groß wie der Tail eines großen Servers mit denselben sechzehn Kernen. Eine Flotte kleiner Server verhält sich wie kleine Server, nicht wie ein großer Server.
Diese Spalten stammen aus dem Modell. Unsere eigene Messung von Flotten auf echten Maschinen ist Thema einer kommenden Anleitung.
Öffne die vier Designs in der App:
- Ein kleiner Server (2 Kerne)
- Acht kleine Server, zufällig gewählt
- Acht kleine Server hinter einem Load Balancer
- Ein großer Server (16 Kerne)
Was du dagegen tun kannst
- Plane nach Auslastung, pro Schicht. Für eine Schicht auf Maschinen mit wenigen Kernen sind 60–70 % in der täglichen Spitze der Bereich, in dem p99 noch nahe an seinem Leerlaufwert liegt. Große Maschinen können heißer laufen, aber lass Luft: Ihr Knick ist schärfer.
- Miss deine eigene Kurve. Erhöhe die Last in Stufen und notiere bei jeder Stufe CPU und p99, mit einem Lastgenerator, der weiter nach Plan sendet, wenn das System langsamer wird (Open Loop). Ein Generator, der auf jede Antwort wartet, wird mit dem System langsamer und versteckt den Knick.
- Glätte die Ankünfte. Verteile geplante Jobs über die Minute, statt sie auf die volle Stunde zu legen, stell eine Warteschlange vor Batch-Arbeit und gib Retries ein Backoff mit Jitter: siehe Retry-Stürme: warum Retries deinen Dienst lahmlegen.
- Bündle Warteschlangen, wo du kannst. Eine Warteschlange vor vielen Workern schlägt viele Warteschlangen mit je einem Worker. Ein Connection-Pool vor einer Datenbank ist so eine gemeinsame Warteschlange: siehe Wie groß sollte dein Connection-Pool für die Datenbank sein? Wenige, größere Maschinen bündeln besser als viele kleine, um den Preis, dass mehr verloren geht, wenn eine ausfällt.
- Halte langsame Arbeit von schneller Arbeit fern. Ein Bericht, der zwei Sekunden braucht, im selben Pool wie eine Abfrage, die zwei Millisekunden braucht, macht das p99 der Abfrage zur Sache des Berichts.
Was diese Seite dir nicht sagt
- Die Formeln sind ein Modell. Sie setzen zufällige Ankünfte, exponentialverteilte Arbeit und eine Warteschlange voraus, die nie aufgibt. Echte Arbeit schwankt oft weniger (niedrigere Latenzen als in der Tabelle), und echte Ankünfte kommen oft stoßweiser (höhere).
- Nur das Warten auf einen Kern. Garbage Collection, Locks, Warten auf Platte und Netzwerk, ein voller Connection-Pool und laute Nachbarn setzen ihre eigenen Tails obendrauf.
- vCPUs sind nicht immer Kerne. Zwei Hyperthreads eines Kerns leisten weniger als zwei Kerne, deshalb kommt der Knick auf vielen Maschinentypen früher, als die Zahl der vCPUs vermuten lässt.
- Das Live-Modell ist keine Messung. Es folgt der Rechnung. Im einen Vergleich mit einer echten Maschine, den wir veröffentlicht haben, dem 12-Dollar-Server, hat das Modell den Knick auf 5 % genau gefunden, und jenseits des Knicks war sein p99 um den Faktor 1,7–2 zu niedrig. Wie genau ist Stackrig? beantwortet eine andere Frage: wie genau das Live-Modell mit einer exakten Simulation übereinstimmt.
- Eine Messung. Die Postgres-Zahlen sind eine Arbeitslast auf einem Maschinentyp an einem Tag.
Quellen
- J. F. C. Kingman, The single server queue in heavy traffic, Mathematical Proceedings of the Cambridge Philosophical Society 57 (1961): die Näherung für die Wartezeit bei allgemeinen Ankünften und allgemeiner Arbeit.
- A. K. Erlang, Solution of some Problems in the Theory of Probabilities of Significance in Automatic Telephone Exchanges, Elektroteknikeren 13 (1917): der Anteil der Ankünfte, die warten müssen, wenn sich mehrere Bediener eine Warteschlange teilen.
- Mor Harchol-Balter, Performance Modeling and Design of Computer Systems, Cambridge University Press (2013): die Herleitungen der hier verwendeten Formeln für die Antwortzeit.
- Jeffrey Dean und Luiz André Barroso, The Tail at Scale, Communications of the ACM 56 (2013): warum das langsamste Hundertstel entscheidet, wie sich ein Dienst aus vielen Teilen anfühlt.
„Web app with database“ im Playground öffnen
Die App kannst du kostenlos im Browser ausprobieren, ohne Konto. Um zu erfahren, wann Pro fertig ist, trag dich in die Warteliste ein.