CPU-Topologie, Prozesse und Rechenzeit unter Linux

Wie viele Aufgaben kann ein Rechner gleichzeitig bearbeiten? Warum zeigt ein Prozess mehr als 100 Prozent CPU-Auslastung? Und weshalb kann ein Programm langsam sein, obwohl die CPU-Anzeige noch freie Kapazität meldet?

Um solche Beobachtungen einzuordnen, müssen drei Ebenen zusammen betrachtet werden: die Struktur der verfügbaren Prozessoren, die ausführbaren Threads der Programme und die Verteilung der Rechenzeit durch den Kernel. Linux stellt dafür unterschiedliche Informationen und Werkzeuge bereit.

CPU ist nicht immer gleich CPU

Im Alltag bezeichnet „CPU“ häufig den gesamten Prozessorchip. In Linux-Ausgaben ist damit dagegen oft eine logische CPU gemeint: eine Ausführungseinheit, die der Kernel einzeln verwalten und für die Ausführung eines Threads auswählen kann.

Für die Hardwareübersicht sind deshalb mehrere Begriffe wichtig:

BegriffBedeutung
Sockel beziehungsweise PackageEinordnung eines Prozessorpakets in der erkannten Hardwaretopologie
KernPhysische Recheneinheit innerhalb eines Prozessors
Logische CPUVom Betriebssystem einzeln verwaltete Ausführungseinheit
SMTTechnik, durch die ein physischer Kern mehrere Hardwarethreads bereitstellt
NUMA-KnotenEinordnung von CPUs und Speicher nach ihrer Nähe und ihren Zugriffseigenschaften

Diese Beziehungen gehören zur CPU-Topologie. Sie lassen sich mit lscpu untersuchen.

Beispiel: Acht Kerne, aber 16 CPUs

Ein Prozessor mit acht Kernen und zwei Hardwarethreads pro Kern stellt Linux typischerweise 16 logische CPUs bereit.

Das bedeutet jedoch nicht, dass 16 voneinander unabhängige physische Kerne vorhanden sind. Die beiden Hardwarethreads eines Kerns teilen sich Ressourcen dieses Kerns. SMT kann vorhandene Ausführungsmöglichkeiten besser nutzen, verdoppelt aber nicht pauschal die Rechenleistung.

Bei Leistungsfragen ist deshalb nicht nur die Anzahl sichtbarer CPUs wichtig, sondern auch deren Beziehung zueinander.

Die erkannte Topologie untersuchen

Die CPU-Topologie beschreibt den Aufbau und die Beziehungen der Prozessoreinheiten eines Systems: Welche logischen CPUs gehören zu welchem Kern und Sockel, welche teilen sich Caches und welchen NUMA-Knoten sind sie zugeordnet? Unter Linux lässt sich diese Struktur mit lscpu anzeigen.

Eine erste Übersicht liefert:

lscpu

Besonders interessant sind die Angaben zu:

  • Anzahl der logischen CPUs.
  • Threads pro Kern.
  • Kernen pro Sockel.
  • Sockeln.
  • NUMA-Knoten.
  • Caches und deren gemeinsamer Nutzung.

Eine tabellarische Zuordnung lässt sich beispielsweise so anzeigen:

lscpu -e=CPU,CORE,SOCKET,NODE,ONLINE

Damit wird sichtbar, welche logischen CPUs zu welchen Kernen, Sockeln und NUMA-Knoten gehören und ob sie online sind. Die CPU-Nummer allein verrät diese Beziehungen nicht zuverlässig.

In virtuellen Maschinen gilt die Gastsicht

Innerhalb einer virtuellen Maschine zeigt lscpu hauptsächlich die vom Hypervisor bereitgestellte Konfiguration. Acht virtuelle CPUs sind daher kein Beleg für acht exklusiv zugewiesene physische Kerne des Hosts. Auch die dargestellte Sockel- und Kerntopologie kann von der tatsächlichen Hardware abweichen.

Prozesse und Threads: Wer bekommt Rechenzeit?

Ein Prozess bildet den Rahmen für ein laufendes Programm. Er besitzt unter anderem einen eigenen virtuellen Adressraum und verwaltet Ressourcen wie geöffnete Dateien.

Innerhalb eines Prozesses können ein oder mehrere Softwarethreads arbeiten. Threads desselben Prozesses teilen sich viele Ressourcen, besitzen aber jeweils einen eigenen Ausführungszustand und Stack.

Für die CPU-Zuteilung ist entscheidend: Linux plant die einzelnen Threads ein. Ein Prozess mit mehreren rechenbereiten Threads kann deshalb gleichzeitig auf mehreren logischen CPUs laufen.

Hardwarethreads und Softwarethreads unterscheiden

Das Wort „Thread“ wird dabei in zwei Bedeutungen verwendet:

BegriffGemeint ist
HardwarethreadEine vom Prozessor bereitgestellte logische CPU, beispielsweise durch SMT
SoftwarethreadEin Ausführungsstrang innerhalb eines Prozesses

Viele Softwarethreads teilen sich die verfügbaren logischen CPUs. Es muss keine feste Eins-zu-eins-Zuordnung zwischen ihnen geben.

Ein einzelner Softwarethread kann zu einem Zeitpunkt nur auf einer logischen CPU ausgeführt werden. Er kann später auf eine andere CPU wechseln, nutzt aber nicht gleichzeitig mehrere CPUs für seine eigene Ausführung.

Der Scheduler verteilt die Ausführungsmöglichkeiten

Der Scheduler ist der Teil des Kernels, der entscheidet, welcher ausführbare Thread auf welcher CPU laufen darf.

Dabei berücksichtigt Linux unter anderem:

  • Die Scheduling-Klasse und Priorität.
  • Welche Threads gerade ausführbar sind.
  • Die erlaubten CPUs eines Threads.
  • Gruppenbezogene Ressourcenregeln.
  • Die Verteilung der Arbeit über die verfügbaren CPUs.

Ein vorhandener Thread benötigt nicht ständig CPU-Zeit. Er kann beispielsweise schlafen, auf Daten warten oder auf eine Synchronisation mit anderen Threads angewiesen sein.

Dadurch können auf einem System sehr viele Prozesse und Threads existieren, obwohl nur wenige gleichzeitig rechnen.

Gleichzeitigkeit und Parallelität

Auf einer einzelnen logischen CPU wechseln sich ausführbare Threads ab. Durch diese zeitliche Aufteilung können mehrere Aufgaben gleichzeitig in Bearbeitung erscheinen.

Mit mehreren logischen CPUs können zusätzlich mehrere Threads tatsächlich parallel ausgeführt werden. Ob ein Programm davon profitiert, hängt davon ab, ob es seine Arbeit auf mehrere gleichzeitig ausführbare Threads verteilen kann.

Mehr CPUs beschleunigen daher nicht automatisch jedes Programm.

Rechenzeit ist nicht dasselbe wie verstrichene Zeit

Eine zentrale Unterscheidung besteht zwischen Laufzeit und verbrauchter CPU-Zeit:

MessgrößeBedeutung
Verstrichene ZeitZeit zwischen Start und Ende, einschließlich Wartezeiten
User-CPU-ZeitZeit für die Ausführung von Anwendungscode im Benutzermodus
System-CPU-ZeitZeit, in der der Kernel im Auftrag des Programms arbeitet
Gesamte CPU-ZeitSumme aus User- und System-CPU-Zeit

Wartezeit wird dabei nicht einfach als CPU-Zeit des wartenden Prozesses gezählt. Ein Programm kann lange laufen, ohne entsprechend viel Rechenzeit zu verbrauchen.

Beispiel: Zehn Sekunden Laufzeit, zwei Sekunden CPU-Zeit

Ein Programm läuft zehn Sekunden, benötigt aber insgesamt nur zwei Sekunden CPU-Zeit.

Während der übrigen Zeit hat es nicht selbst gerechnet. Es könnte beispielsweise auf Eingaben, Daten, andere Threads oder eine freie CPU gewartet haben. Aus der Zeitdifferenz allein lässt sich die genaue Ursache noch nicht bestimmen.

Beispiel: Zehn Sekunden Laufzeit, 35 Sekunden CPU-Zeit

Auch das ist möglich: Mehrere Threads können parallel auf unterschiedlichen CPUs rechnen. Ihre CPU-Zeiten werden addiert.

35 Sekunden CPU-Zeit innerhalb von zehn Sekunden verstrichener Zeit entsprechen im Mittel der Nutzung von 3,5 logischen CPUs. Das ist eine Aussage über die aufsummierte Ausführungszeit, nicht über die erreichte Rechenleistung oder Effizienz.

Laufzeit und CPU-Zeit mit time messen

Für einen Programmlauf lässt sich die Zeitmessung beispielsweise so aufrufen:

time -p meinprogramm

Eine beispielhafte Ausgabe:

real 10.00
user 1.70
sys 0.30

Das bedeutet:

  • Zwischen Start und Ende vergingen zehn Sekunden.
  • 1,7 Sekunden entfielen auf Anwendungscode.
  • 0,3 Sekunden entfielen auf Kernelarbeit im Auftrag des Programms.

Die CPU-Zeit beträgt damit insgesamt zwei Sekunden.

Viele Shells besitzen eine eigene time-Funktion oder ein entsprechendes Schlüsselwort. Daneben kann ein eigenständiges Programm wie /usr/bin/time installiert sein. Umfang und Darstellung der Ausgabe können sich unterscheiden.

Warum Prozesse mehr als 100 Prozent CPU anzeigen können

In der üblichen Darstellung vieler Prozessanzeigen entsprechen 100 Prozent der vollständigen zeitlichen Nutzung einer logischen CPU.

Ein Prozess mit mehreren aktiven Threads kann deshalb beispielsweise 250 Prozent erreichen. Das entspricht über das Messintervall ungefähr 2,5 vollständig genutzten logischen CPUs.

Die Bezugsgröße ist jedoch werkzeugabhängig. top kann die Prozessauslastung auch auf die Gesamtzahl der CPUs normieren. Dann verändert sich die Bedeutung der Prozentwerte.

Vor einem Vergleich sollte deshalb geklärt werden:

  • Bezieht sich der Wert auf eine logische CPU oder auf das ganze System?
  • Werden einzelne Threads oder zusammengefasste Prozesse angezeigt?
  • Handelt es sich um ein aktuelles Messintervall oder einen längerfristigen Durchschnitt?

CPU-Auslastung ist keine direkte Leistungsangabe

100 Prozent CPU bedeuten nicht, dass ein Programm die maximal mögliche Menge sinnvoller Arbeit erledigt. Unterschiedliche Programme können bei gleicher CPU-Zeit sehr unterschiedliche Arbeit leisten. Auch ist die Nutzung einer logischen SMT-CPU nicht gleichbedeutend mit einem exklusiv genutzten physischen Kern.

CPU-Auslastung beschreibt vor allem die zeitliche Belegung. Für die Leistungsbewertung muss zusätzlich betrachtet werden, wie viel Arbeit dabei tatsächlich fertig wird.

Prozesse und einzelne Threads beobachten

Eine laufende Übersicht bietet:

top

Innerhalb von top schaltet die Taste H zwischen einer Prozessansicht und der Darstellung einzelner Threads um.

Für die Threads eines bestimmten Prozesses:

top -H -p 1234

1234 steht dabei für die PID des untersuchten Prozesses.

Diese Unterscheidung ist bei vermeintlich schlecht ausgelasteten Systemen hilfreich: Ein Prozess kann insgesamt nur ungefähr eine logische CPU nutzen, weil lediglich einer seiner Threads dauerhaft rechnet. Freie CPUs können diese einzelne Ausführung nicht automatisch aufteilen.

Eine Auslastungsübersicht pro logischer CPU liefert außerdem:

mpstat -P ALL 1

Der Aufruf aktualisiert die Werte im Sekundenabstand. mpstat gehört zum Paket sysstat und ist nicht überall vorinstalliert.

Load Average ist kein CPU-Prozentwert

Die Load Average wird beispielsweise von uptime und top angezeigt. Die drei Werte beziehen sich auf Zeiträume von einer, fünf und 15 Minuten.

Linux berücksichtigt dabei sowohl ausführbare Aufgaben als auch Aufgaben im nicht unterbrechbaren Wartezustand, häufig aufgrund von I/O. Die Load Average beschreibt deshalb nicht ausschließlich den Bedarf an CPU-Rechenzeit.

Das hat wichtige Folgen:

  • Eine hohe Load kann durch viele rechenbereite Threads entstehen.
  • Sie kann aber auch durch zahlreiche blockierte Aufgaben steigen.
  • Der Wert wird nicht automatisch durch die Anzahl der CPUs geteilt.

Eine Load von acht hat auf einem System mit zwei logischen CPUs eine andere Bedeutung als auf einem System mit 32. Trotzdem reicht auch dieser Vergleich allein nicht: Entscheidend ist, ob die Aufgaben rechnen wollen oder überwiegend auf etwas anderes warten.

Eine hohe Load bei niedriger CPU-Auslastung ist daher kein Widerspruch.

Priorität, Gewicht und Quote sind unterschiedliche Werkzeuge

Linux bietet mehrere Möglichkeiten, die Verteilung von Rechenzeit zu beeinflussen. Sie beantworten unterschiedliche Fragen.

MechanismusFragestellung
Nice-WertWie soll ein Thread innerhalb der betreffenden normalen Scheduling-Regeln gegenüber anderen gewichtet werden?
CPU-Gewicht einer cgroupWelchen relativen Anteil soll eine Prozessgruppe bei Konkurrenz erhalten?
CPU-QuoteWie viel CPU-Zeit darf eine Gruppe innerhalb eines Zeitraums höchstens verbrauchen?
CPU-AffinitätAuf welchen logischen CPUs darf ein Thread laufen?

Diese Mechanismen sind nicht austauschbar. Insbesondere bedeutet eine höhere Priorität weder eine feste Reservierung noch eine garantierte Beschleunigung.

Nice: Relative Bevorzugung statt fester Begrenzung

Für die üblichen Nice-basierten Scheduling-Regeln liegt der Wertebereich unter Linux zwischen −20 und +19:

  • Niedrigere Werte bedeuten stärkere Bevorzugung.
  • Höhere Werte bedeuten geringere Bevorzugung.

Das ist keine Begrenzung auf einen bestimmten CPU-Prozentsatz. Ein weniger bevorzugter Thread kann weiterhin viel CPU-Zeit erhalten, wenn keine entsprechende Konkurrenz vorhanden ist. Außerdem beeinflussen Gruppenregeln und andere Scheduling-Klassen die tatsächliche Verteilung.

CPU-Gewicht: Verteilung bei Konkurrenz

Ein cgroup-Gewicht beeinflusst den relativen Anteil konkurrierender Gruppen. Es setzt für sich genommen keine harte Obergrenze.

Sind andere Gruppen nicht aktiv, kann eine Gruppe daher mehr Rechenzeit nutzen, als ihr rechnerischer Anteil bei vollständiger Konkurrenz erwarten ließe.

CPU-Quote: Eine tatsächliche Obergrenze

Eine Quote begrenzt dagegen das CPU-Zeitbudget einer Gruppe pro Zeitraum. Ist dieses Budget verbraucht, kann die Gruppe bis zur nächsten Freigabe gedrosselt werden – auch wenn ansonsten CPUs frei wären.

Bei systemd beziehen sich Werte wie CPUQuota=100% auf die Zeitkapazität einer logischen CPU. Für eine Zeitkapazität von zwei CPUs kann beispielsweise CPUQuota=200% verwendet werden.

Das bedeutet nicht, dass die Gruppe exklusiv genau diesen CPUs zugeordnet wird. Die Quote begrenzt das zusammengezählte Zeitbudget, nicht die Auswahl der CPUs.

CPU-Affinität: Wo ein Thread laufen darf

Die CPU-Affinität legt fest, auf welchen logischen CPUs ein Thread ausgeführt werden darf.

Die erlaubten CPUs eines Prozesses beziehungsweise seines Hauptthreads lassen sich beispielsweise anzeigen mit:

taskset -pc 1234

Für alle vorhandenen Threads des Prozesses:

taskset -apc 1234

Unter Linux ist die Affinität eine Eigenschaft des einzelnen Threads. Unterschiedliche Threads desselben Prozesses können deshalb unterschiedliche Zuordnungen besitzen.

Wichtig ist die Abgrenzung: Eine Affinität reserviert die ausgewählten CPUs nicht exklusiv. Andere dort zugelassene Threads können sie weiterhin verwenden.

Eine zu enge Bindung kann außerdem Kapazität ungenutzt lassen. Affinität ist daher kein allgemeiner Beschleunigungsschalter, sondern ein gezieltes Werkzeug zur Platzierung von Arbeit.

NUMA: Rechenzeit und Speicherplatzierung hängen zusammen

Auf NUMA-Systemen unterscheiden sich Speicherzugriffe je nach Nähe zwischen CPU und Speicher. Speicher eines nahen Knotens ist typischerweise günstiger erreichbar als weiter entfernter Speicher.

NUMA-Systeme (Non-Uniform Memory Access) sind Rechner, bei denen Prozessoren auf nahe gelegenen Arbeitsspeicher schneller zugreifen können als auf weiter entfernten. Sie kommen besonders in leistungsfähigen Servern zum Einsatz, um viele Prozessorkerne und große Speichermengen bereitzustellen.

Die CPU-Zuordnung allein beschreibt deshalb noch nicht die gesamte Ausführungssituation. Relevant ist auch, aus welchen NUMA-Knoten ein Prozess seinen Speicher bezieht.

Der cpuset-Controller von cgroups kann sowohl die erlaubten CPUs als auch die erlaubten Speicherknoten einschränken. Damit lassen sich Rechen- und Speicherplatzierung aufeinander abstimmen.

Das erklärt, warum zwei Programme trotz ähnlicher CPU-Auslastung unterschiedliche Laufzeiten haben können: Nicht jede Sekunde belegter CPU-Zeit führt unter unterschiedlichen Speicherbedingungen zum gleichen Arbeitsergebnis.

Besonderheiten in Containern und virtuellen Maschinen

Bei Containern müssen sichtbare CPU-Topologie und tatsächlich verfügbares CPU-Zeitbudget unterschieden werden. Eine cgroup kann beispielsweise eine Quote vorgeben, die deutlich unter der Kapazität aller sichtbaren CPUs liegt. Freie CPUs des Hosts bedeuten dann nicht automatisch, dass der Container zusätzliche Rechenzeit erhalten darf.

In virtuellen Maschinen kommt eine weitere Ebene hinzu: Der Hypervisor muss die virtuellen CPUs auf dem Host einplanen.

Werkzeuge wie top oder mpstat können dafür Steal Time anzeigen. Sie kennzeichnet Zeit, in der eine virtuelle CPU aufgrund der Einplanung durch den Hypervisor nicht selbst laufen konnte. Hohe Steal-Werte können somit einen Teil der Verzögerung erklären, den eine reine Prozessbetrachtung innerhalb des Gasts nicht sichtbar macht.

Eine sinnvolle Reihenfolge für die Fehlersuche

Wenn ein Programm zu langsam arbeitet, hilft eine schrittweise Betrachtung:

  1. Mit lscpu klären, welche CPU-Struktur das System sieht.
  2. Mit top oder mpstat prüfen, ob alle CPUs oder nur einzelne ausgelastet sind.
  3. In der Threadansicht feststellen, wie viele Threads tatsächlich rechnen.
  4. Verstrichene Zeit und CPU-Zeit vergleichen.
  5. Load Average und mögliche Wartezustände gemeinsam betrachten.
  6. Affinität, cgroup-Gewichte und CPU-Quoten prüfen.
  7. Bei NUMA- oder virtuellen Systemen die zusätzlichen Platzierungs- und Einplanungsebenen berücksichtigen.

Damit werden drei unterschiedliche Ursachen auseinandergehalten: fehlende Parallelität, fehlende Zuteilung von Rechenzeit und Wartezeiten außerhalb der eigentlichen Berechnung. Die genannten Werkzeuge betrachten jeweils einen Teil dieses Gesamtbilds.

Fazit: CPU-Anzahl allein erklärt die Leistung nicht

Die CPU-Topologie beschreibt die verfügbaren Ausführungseinheiten und ihre Beziehungen. Prozesse stellen mit ihren Threads die ausführbare Arbeit bereit. Der Scheduler verteilt darauf die verfügbare Rechenzeit – innerhalb von Prioritäten, erlaubten CPUs und möglichen Gruppenlimits.

Für die Beurteilung eines Systems müssen deshalb Hardwarestruktur, Threadverhalten, Zeitverbrauch und Wartezustände zusammenpassen. Erst dann lässt sich sinnvoll entscheiden, ob mehr CPUs helfen, eine Anwendung stärker parallelisiert werden müsste oder eine Begrenzung beziehungsweise ein anderer Engpass die eigentliche Ursache ist.


, , , ,
Fediverse reactions
Andreas Moor
Andreas Moor
@blog@andreas-moor.de

Hallo Fediverse, ich bin Andy!

Hier und auf meiner Website findest du mein akkumuliertes Linux-Sysadmin-Wissen, meine kleinen und größeren Projekte und die Tools, die ich nutze.

Viel Spaß beim stöbern, lesen und lernen! 🧑‍💻

61 Beiträge
40 Folgende