HOWTO · C
Die Funktion sched_setaffinity in C verwenden
Dieser Artikel beschreibt die Verwendung der Funktion sched_setaffinity in C.
Auf dieser Seite
Verwenden Sie sched_setaffinity unter Linux, um festzulegen, auf welchen CPUs ein Prozess oder Thread ausgeführt werden darf. Die Funktion beeinflusst, wo der Task eingeplant werden kann; sie reserviert keine CPU, erzwingt keine sofortige Migration und garantiert keine schnellere Ausführung. Sie gehört zur GNU/Linux-Schnittstelle und ist kein portabler Bestandteil von ISO C.
sched_setaffinity verwenden, um die CPU-Affinität festzulegen
Definieren Sie _GNU_SOURCE, bevor Sie Headerdateien einbinden, damit die GNU-Deklarationen verfügbar sind. Binden Sie außerdem <sched.h> für cpu_set_t und dessen CPU-Maskenmakros ein. Ein cpu_set_t stellt eine Menge von CPU-IDs dar. Leeren Sie die Maske zunächst mit CPU_ZERO(&set). Rufen Sie dann für jede CPU, die der Task verwenden darf, CPU_SET(cpu_id, &set) auf. Übergeben Sie sched_setaffinity die Größe und die Adresse der Maske.
Das erste Argument bezeichnet den Ziel-Task: Übergeben Sie 0, um die Affinität des aufrufenden Threads zu ändern, oder eine positive Linux-Thread-ID, um einen anderen Task anzugeben. Das zweite Argument ist die Größe des Maskenobjekts in Bytes, üblicherweise sizeof(set). Das dritte Argument ist ein Zeiger auf die Maske. Bei Erfolg gibt der Aufruf 0 zurück; bei einem Fehler liefert er -1 und setzt errno. Prüfen Sie daher den Rückgabewert und lassen Sie sich den Fehler mit perror oder strerror anzeigen.
Eine CPU-ID muss für die Maske gültig und vom System unterstützt sein. Systembeschränkungen, etwa durch ein cpuset, begrenzen die tatsächlich wirksame Affinitätsmaske: Der Aufruf kann erfolgreich sein, wenn mindestens eine angeforderte CPU weiterhin verfügbar ist, auch wenn andere angeforderte CPUs eingeschränkt sind. Er kann mit EINVAL fehlschlagen, wenn keine angeforderte CPU mehr verfügbar ist oder eine CPU-ID außerhalb des unterstützten Bereichs liegt. Fehlende Berechtigungen zum Ändern der Affinität eines anderen Tasks können zu EPERM führen. Fragen Sie die aktuell erlaubte CPU-Menge mit sched_getaffinity ab, wenn das Programm passende IDs für das jeweilige System auswählen muss. Ein Kindprozess übernimmt die Affinität bei fork, kann seine Maske danach aber selbst ändern. Deshalb sollte ein Beispiel verfügbare IDs ermitteln, statt vorauszusetzen, dass CPU 0 oder CPU 1 verwendet werden kann.
Ein Eltern-Kind-Beispiel mit CPU_SET erstellen
Dieses Programm fragt den Kernel nach den CPUs, die dem aufrufenden Task zur Verfügung stehen, wählt nach Möglichkeit zwei IDs aus und verwendet die erste für den Elternprozess und die zweite für das Kind. Ist nur eine CPU erlaubt, verwenden beide Masken diese CPU. Jeder Prozess setzt seine eigene Affinität, indem er 0 übergibt. Der Elternprozess wartet auf das Kind und prüft, ob es erfolgreich beendet wurde. CPU_ZERO initialisiert jede der beiden Masken; CPU_SET fügt jeweils die ausgewählte CPU hinzu.
Führen Sie dieses Beispiel aus:
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
#define _GNU_SOURCE
#include <errno.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
int main(void) {
cpu_set_t allowed, parent_set, child_set;
int first = -1, second = -1;
if (sched_getaffinity(0, sizeof(allowed), &allowed) == -1) {
perror("sched_getaffinity");
return EXIT_FAILURE;
}
for (int cpu = 0; cpu < CPU_SETSIZE; cpu++) {
if (CPU_ISSET(cpu, &allowed)) {
if (first == -1)
first = cpu;
else if (second == -1)
second = cpu;
}
}
if (first == -1) {
fputs("No allowed CPU was reported.\n", stderr);
return EXIT_FAILURE;
}
if (second == -1)
second = first;
CPU_ZERO(&parent_set);
CPU_SET(first, &parent_set);
CPU_ZERO(&child_set);
CPU_SET(second, &child_set);
pid_t child = fork();
if (child == -1) {
perror("fork");
return EXIT_FAILURE;
}
if (child == 0) {
if (sched_setaffinity(0, sizeof(child_set), &child_set) == -1) {
perror("child sched_setaffinity");
_exit(EXIT_FAILURE);
}
_exit(EXIT_SUCCESS);
}
if (sched_setaffinity(0, sizeof(parent_set), &parent_set) == -1) {
perror("parent sched_setaffinity");
int status;
while (waitpid(child, &status, 0) == -1 && errno == EINTR) {}
return EXIT_FAILURE;
}
int status;
pid_t waited;
do {
waited = waitpid(child, &status, 0);
} while (waited == -1 && errno == EINTR);
if (waited == -1) {
perror("waitpid");
return EXIT_FAILURE;
}
if (!WIFEXITED(status) || WEXITSTATUS(status) != EXIT_SUCCESS) {
fputs("The child did not set its affinity successfully.\n", stderr);
return EXIT_FAILURE;
}
puts("Affinity set for parent and child.");
return EXIT_SUCCESS;
}
Affinity set for parent and child.
Das bereitgestellte Laufzeitergebnis für dieses Programm ist die oben gezeigte Erfolgsmeldung; der Exit-Status beträgt 0. Die Meldung im unveränderten Ausgabeblock lautet auf Englisch: „Affinity set for parent and child.“ Speichern Sie das Programm zum Kompilieren mit GCC als affinity.c und verwenden Sie gcc -std=c11 -Wall -Wextra affinity.c -o affinity. Starten Sie es anschließend mit ./affinity. Die Meldung bestätigt, dass beide Aufrufe zur Änderung der Affinität erfolgreich waren und der Kindprozess normal beendet wurde. Wird nur eine erlaubte CPU gemeldet, läuft das Programm zwar erfolgreich, demonstriert aber keine unterschiedlichen CPUs für Elternprozess und Kind. Container, Dienste oder Administratoren können die verfügbare CPU-Menge weiter einschränken. Werkzeuge wie taskset -pc PID können die Affinität eines Tasks auf Systemen anzeigen, die taskset bereitstellen. Um einen kurzlebigen Kindprozess zu beobachten, muss er möglicherweise kurz am Leben gehalten werden. Weder die Schnittstelle noch dieses Beispiel belegen eine Leistungssteigerung.