Stackrig

Startseite Blog

erklärt Warteschlangen-Rechnung, unsere eigene Postgres-Messung und das Live-Modell veröffentlicht

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:

Berechnet, nicht gemessen: p99-Antwortzeit einer Anfrage mit 10 ms mittlerer Arbeit, zufälligen (Poisson-)Ankünften, exponentialverteilter Arbeit und einer gemeinsamen Warteschlange vor den Kernen (die M/M/c-Warteschlange). Ganz ohne Warten liegt das p99 bei 46 ms, dem langsamsten Hundertstel der Arbeit selbst.
CPU-Auslastung1 Kern2 Kerne16 Kerne
50 %92 ms57 ms46 ms
70 %154 ms83 ms46 ms
80 %230 ms119 ms47 ms
90 %461 ms233 ms53 ms
95 %921 ms463 ms72 ms
Berechnete p99-Antwortzeit über der CPU-Auslastung für eine Anfrage von 10 ms: Auf einem Kern steigt sie von 92 ms bei 50 % auf 230 ms bei 80 % und überschreitet 500 ms bei 91 %; auf sechzehn Kernen bleibt sie bis 85 % nahe 46 ms und steigt dann steil an, auf etwa 300 ms bei 99 %. 0 50 % 80 % 100 % 0 250 500 ms 1 Kern 16 Kerne
p99 über der CPU-Auslastung: dieselben Formeln wie in der Tabelle, gezeichnet. Sechzehn Kerne bleiben länger flach und steigen dann schneller: Bei 99 % liegen sie bei etwa 300 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:

Gemessen am 2026-09-30 auf Google Cloud n2-standard-2 (2 vCPU = zwei Hyperthreads eines Kerns). p99 der ganzen HTTP-Anfrage: die Anwendung, zwei Netzwerk-Hops und eine Abfrage. Bei der letzten Stufe überstieg die angebotene Last, was die Datenbank bedienen kann.
Angebotene Anfragen/sDB-CPU (zufällig)p99 zufälligDB-CPU (gleichmäßig)p99 gleichmäßig
6409 %1,4 ms8 %1,1 ms
3.20049 %2,5 ms35 %1,1 ms
4.48070 %5,7 ms58 %1,6 ms
5.12080 %7,3 ms73 %3,3 ms
5.44088 %12,6 ms83 %4,2 ms
5.76094 %21,0 ms91 %6,0 ms
6.08099 %1.966 ms99 %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.

Aus Stackrigs Live-Modell, nicht von echten Maschinen: p99 der Median-Sekunde von 20 nach 100 Sekunden bei jeder Last, gerundet. In den Spalten mit zufälligen Ankünften (alle außer der des Load Balancers) bleibt das Modell für 2 und für 16 Kerne innerhalb von 15 % der Formel oben.
CPU-Auslastung1 kleiner Server8 kleine Server, zufällig gewählt8 kleine Server hinter einem Load Balancer1 großer Server
50 %etwa 60 msetwa 60 msetwa 55 msetwa 50 ms
70 %etwa 85 msetwa 85 msetwa 65 msetwa 50 ms
80 %etwa 125 msetwa 125 msetwa 85 msetwa 50 ms
90 %etwa 230 msetwa 230 msetwa 150 msetwa 50 ms
95 %etwa 460 msetwa 460 msetwa 270 msetwa 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:

Was du dagegen tun kannst

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.

Stackrig