Prozessoraffinität

In der Informatik ermöglicht die Prozessoraffinität , auch CPU-Pinning oder Cache-Affinität genannt , das Binden und Lösen eines Prozesses oder Threads an eine zentrale Verarbeitungseinheit (CPU) oder einen CPU-Bereich. Dadurch wird sichergestellt, dass der Prozess oder Thread nur auf der/den zugewiesenen CPU(s) und nicht auf einer beliebigen CPU ausgeführt wird. ^{[ 1 ]} Dies kann als Modifikation des nativen Warteschlangen- Scheduling-Algorithmus in einem symmetrischen Multiprocessing -Betriebssystem betrachtet werden. Jedes Element in der Warteschlange besitzt ein Tag, das seinen zugehörigen Prozessor angibt . Bei der Ressourcenzuweisung wird jede Aufgabe bevorzugt ihrem zugehörigen Prozessor zugewiesen.

Die Implementierungen von Scheduling-Algorithmen unterscheiden sich hinsichtlich ihrer Berücksichtigung der Prozessoraffinität. Unter bestimmten Umständen erlauben einige Implementierungen, dass eine Aufgabe auf einen anderen Prozessor verschoben wird, wenn dies zu einer höheren Effizienz führt. Wenn beispielsweise zwei rechenintensive Aufgaben (A und B) eine Affinität zu einem Prozessor aufweisen, während ein anderer Prozessor ungenutzt bleibt, verschieben viele Scheduler Aufgabe B auf den zweiten Prozessor, um die Prozessorauslastung zu maximieren. Aufgabe B erhält dadurch eine Affinität zum zweiten Prozessor, während Aufgabe A weiterhin eine Affinität zum ursprünglichen Prozessor behält. ^{[ 2 ]}

Bei den meisten Betriebssystemen wird die Menge der Prozessoren, auf denen ein Prozess oder Thread ausgeführt werden darf (oder bevorzugt wird), als Affinitätsmaske ausgedrückt . Diese ist eine Bitmaske , die den Kernen des Systems entspricht. ^{[ 3 ]}

Es gibt mehrere Gründe für die Verwendung von Prozessoraffinität.

Die Ausführung eines Threads kann vom Betriebssystem-Scheduler unterbrochen werden, um während eines Interrupts Platz für andere Programme oder Threads zu schaffen. Wird der Thread später auf dem Prozessor ausgeführt, auf dem er zuvor lief, können noch Daten im CPU-Cache vorhanden sein , die wiederverwendet werden können, wodurch Cache-Fehler reduziert werden . ^{[ 4 ]} Durch Festlegen der Prozessoraffinität wird sichergestellt, dass der Thread immer auf demselben Prozessor (bzw. denselben Prozessoren) ausgeführt wird. Gleichzeitig wird er jedoch gezwungen, auf die erneute Verfügbarkeit des Prozessors (bzw. der Prozessoren) zu warten. Diese Funktion ist besonders nützlich für rechenintensive Prozesse mit wenigen Interrupts. Bei einem normalen Programm könnte dies hingegen zu einer Verlangsamung führen, da diese Programme häufiger unterbrochen werden und somit länger warten müssen. ^{[ 5 ]} Ein praktisches Beispiel für Prozessoraffinität ist die Ausführung mehrerer Instanzen einer Single-Thread-Anwendung, wie beispielsweise mancher Grafiksoftware. ^{[ 6 ]}

Bei CPUs mit Simultaneous Multithreading (SMT, auch bekannt als Hyper-Threading , eine generische Marke von Intel) teilen sich die zwei oder mehr „Threads“ (logische Prozessoren, „virtuelle Kerne“) eines physischen Kerns den L1- und L2-Cache. Hinsichtlich der Datenlokalität sind sie identisch. ^{[ 7 ]}

Auf NUMA-Systemen ( Non-Uniform Memory Access ) besteht ein ähnliches Problem, allerdings wird die Latenz hier nicht durch L1/L2-Cache-Fehler, sondern durch L3-Cache-Fehler und speicherübergreifende Zugriffe zwischen Knoten verursacht. Durch die Beschränkung aller Threads eines Programms auf denselben NUMA-Knoten (oder zumindest denselben CPU-Sockel) kann sichergestellt werden, dass sie ihre L3-Caches gemeinsam nutzen. Gegebenenfalls sind zusätzliche Konfigurationen erforderlich, um die Speicherzuweisung vom lokalen NUMA-Knoten zu gewährleisten. ^{[ 8 ] [ 9 ]}

Die Prozessoraffinität erzwingt eine statische Aufteilung der Rechenressourcen. Dadurch kann die Anzahl der von einem rechenintensiven Prozess genutzten CPU-Kerne begrenzt werden, sodass andere Kerne für andere Programme zur Verfügung stehen. Dies ist jedoch nicht optimal, da Ressourcen ungenutzt bleiben, wenn keine anderen Programme ausgeführt werden, und andere Programme weiterhin mit dem rechenintensiven Programm um die wenigen ihm zugewiesenen Kerne konkurrieren. Fortgeschrittenere Methoden zur Ressourcenaufteilung umfassen CPU-Prioritätseinstellungen, CPU-Auslastungsanteile und feste Auslastungsgrenzen. ^{[ 10 ] [ 7 ]}

Bei CPUs mit SMT kann es vorkommen, dass Scheduler ohne SMT-Unterstützung fälschlicherweise Aufgaben auf einem nicht ausgelasteten Kern zusammen mit einem ausgelasteten Partner einplanen, wenn freie physische Kerne vorhanden sind. Dies führt zu unnötiger Ressourcenkonkurrenz zwischen den beiden Threads. Daher weisen Multithread-Programme mit hohem CPU-Aufkommen ihren Threads häufig manuell eine Kernaffinität zu, um zu vermeiden, dass diese um denselben physischen Kern konkurrieren. ^{[ 11 ] [ 12 ]}

Unter Linux kann die CPU-Affinität eines Prozesses mit dem Programm taskset(1) ^{[ 13 ]} und dem Systemaufruf sched_setaffinity(2) ^{[ 14 ]} geändert werden. Die Affinität eines Threads kann mit einer der Bibliotheksfunktionen pthread_setaffinity_np(3) oder pthread_attr_setaffinity_np(3) geändert werden.

Auf SGI -Systemen bindet dplace einen Prozess an eine Gruppe von CPUs. ^{[ 15 ]}

Unter NetBSD 5.0, FreeBSD 7.2, DragonFly BSD 4.7 und späteren Versionen können die Funktionen `psrset` pthread_setaffinity_npund `cpuset` verwendet werden pthread_getaffinity_np. ^{[ 16 ]} In NetBSD dient das Dienstprogramm `psrset` ^{[ 17 ]} dazu, die CPU-Affinität eines Threads zu einer bestimmten CPU-Gruppe festzulegen. In FreeBSD wird das Dienstprogramm `cpuset` ^{[ 18 ]} verwendet, um CPU-Gruppen zu erstellen und Prozesse diesen Gruppen zuzuweisen.

Unter DragonFly BSD 1.9 (2007) und späteren Versionen usched_setkann die Prozessaffinität über Systemaufrufe gesteuert werden. ^{[ 19 ] [ 20 ]} In DragonFly BSD 3.1 (2012) und späteren Versionen kann das Dienstprogramm usched verwendet werden, um Prozesse bestimmten CPU-Gruppen zuzuweisen. ^{[ 21 ]}

Unter Solaris lassen sich die Bindungen von Prozessen und LWPs an Prozessoren mit dem Programm pbind(1) ^{[ 22 ]} steuern . Zur programmatischen Steuerung der Affinität kann processor_bind(2) ^{[ 23 ]} verwendet werden. Es stehen außerdem generischere Schnittstellen wie pset_bind(2) ^{[ 24 ]} oder lgrp_affinity_get(3LGRP) ^{[ 25 ]} zur Verfügung , die auf Prozessorsätzen und Lokalitätsgruppen basieren.

Unter AIX können Prozessbindungen mithilfe des Befehls `bindprocessor` ^{[ 26 ] [ 27 ]} und der API `bindprocessor()` gesteuert werden. ^{[ 26 ] [ 28 ]} Der AIX-Scheduler ist SMT-fähig und kann die SMT-Zustände der POWER7/8/9-Kerne von 1 bis 8 Threads umschalten, um den Durchsatz zu maximieren. ^{[ 29 ]}

macOS bietet keine API zur Verwaltung der Prozessoren, auf denen ein Prozess, eine Aufgabe oder ein Thread ausgeführt werden darf. Stattdessen stellt es die Thread-Affinitäts-API bereit, die dem Kernel mitteilt, welche Threads denselben L2-Cache nutzen und somit auf demselben physischen CPU-Kern ausgeführt werden sollen. ^{[ 30 ]} Der XNU- Kernel übersetzt intern jedes Affinitäts-Tag in eine Menge zulässiger logischer Kerne, die jeweils einem physischen Kern entsprechen. Beim Setzen eines Tags wird ein Thread-Affinitäts-Namensraum erstellt, sofern noch keiner existiert. Dieser wird dann an den Kern mit den wenigsten bereits gebundenen Tags gebunden. In XNU Version 8792 werden Tags nicht zwischen Kernen migriert; solange also nicht mehr Tags als physische Kerne vorhanden sind, entspricht jedes Tag genau einem physischen Kern. Namensräume und Tags werden zwischen Eltern- und Kindprozessen vererbt. ^{[ 31 ]}

Die API ist auf arm64 (Apple Silicon) nicht verfügbar, da dort ml_get_max_affinity_setsfest codiert ist, dass sie 0 zurückgibt. ^{[ 32 ]}

Unter Windows NT und seinen Nachfolgern können die CPU-Affinitäten von Threads und Prozessen separat über die API-Aufrufe SetThreadAffinityMask ^{[ 33 ]} und SetProcessAffinityMask ^{[ 34 ]} oder über die Task-Manager-Oberfläche (nur für die Prozessaffinität) festgelegt werden. ^{[ 35 ]}

Die Zuweisung jedes OpenMP- Threads zu einem separaten logischen Kern unter Windows kann mithilfe des folgenden C- Codes und der <Windows.h> -Headerdatei erreicht werden:

#include <Windows.h> #include <omp.h>// OpenMP-Thread-Affinität festlegen void setThreadAffinity ( void ) { #pragma omp parallel default(shared) { DWORD_PTR mask = ( DWORD_PTR ) 1 << omp_get_thread_num (); SetThreadAffinityMask ( GetCurrentThread (), mask ); } }

• hwloc

• MSDN-Artikel zur Funktion SetThreadAffinityMask
• Taskset, ein Tool zum Festlegen der Netzwerkaffinitätsmaske unter Linux
• CPU Balancer ist ein kostenloses Open-Source-Tool, das Windows XP-Prozesse mithilfe der Affinitätsmaske gleichmäßig auf logische Prozessoren verteilt.