🧠 1.
Notions fondamentales : Multiprocesseur, Multicœur et
Hyperthreading
Terme Définition Exemple / Image
Système possédant plusieurs processeurs
physiques (CPU). Chaque processeur a sa Serveur avec 2 CPU distincts
Multiprocesseur
propre mémoire cache, mais ils partagent la sur la carte mère.
RAM.
Un même processeur physique contient
Un CPU Intel i7 à 4 cœurs
Multicœur plusieurs cœurs (unités de calcul
physiques.
indépendantes).
Chaque cœur physique simule plusieurs
Un cœur physique → 2 threads
Hyperthreading cœurs logiques pour exécuter deux threads
logiques (visible comme 8 CPU
(ou SMT) simultanément (en partageant les unités
logiques pour un i7 à 4 cœurs).
d’exécution).
➡️Donc au total, le nombre de processeurs logiques =
🧮 nb_processeurs_physiques × nb_cœurs × nb_threads_par_cœur.
⚙️2. Obtenir les infos système : sysconf()
🔹 Prototype
#include <unistd.h>
long sysconf(int name);
Cette fonction retourne une valeur de configuration du système à l’exécution.
📊 Tableau des attributs utiles pour les processeurs :
Constante Signification Retour de sysconf()
_SC_NPROCESSORS_ Nombre de processeurs configurés Par ex. 8 sur une machine avec
CONF dans le système. hyperthreading activé.
_SC_NPROCESSORS_ Nombre de processeurs Peut être inférieur si certains CPU
ONLN actuellement en ligne (actifs). sont désactivés.
_SC_PHYS_PAGES Nombre de pages physiques de
Sert à estimer la mémoire totale.
mémoire.
_SC_PAGE_SIZE Taille d’une page mémoire
4096 sur x86_64.
(souvent 4096 octets).
🎯 3. Affinité d’une tâche (processus ou thread)
L’affinité d’un processus définit sur quels cœurs il peut s’exécuter.
→ C’est un masque de processeurs (bitmask).
📌 Objectif :
• Améliorer la localité mémoire (moins de cache miss).
• Réduire les migrations de threads entre cœurs.
• Contrôler les performances.
🧩 4. Fonctions principales
🔹 sched_setaffinity()
Permet de fixer les processeurs sur lesquels une tâche peut s’exécuter.
#include <sched.h>
int sched_setaffinity(pid_t pid, size_t cpusetsize, const cpu_set_t *mask);
Paramètre Description
pid PID du processus concerné (0 = le processus courant).
cpusetsize Taille de la structure cpu_set_t.
mask Ensemble des CPU autorisés (géré par macros).
Macros utiles :
CPU_ZERO(&mask); // initialise le masque
CPU_SET(cpu_id, &mask); // ajoute un CPU au masque
exemple:
#include <stdio.h>
#include <sched.h>
#include <unistd.h>
int main() {
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(2, &mask); // Autoriser uniquement le CPU logique 2
if (sched_setaffinity(0, sizeof(mask), &mask) == 0)
printf("Affinité fixée sur CPU 2\n");
else
perror("sched_setaffinity");
}
🔹 sched_getaffinity()
Permet de lire le masque de processeurs autorisés pour une tâche.
int sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask);
🧩 Exemple :
cpu_set_t mask;
CPU_ZERO(&mask);
sched_getaffinity(0, sizeof(mask), &mask);
for (int i = 0; i < CPU_SETSIZE; i++)
if (CPU_ISSET(i, &mask))
printf("CPU %d autorisé\n", i);
🧭 5. Savoir sur quel CPU on s’exécute : sched_getcpu()
🔹 Prototype
#include <sched.h>
int sched_getcpu(void);
Retourne l’ID du CPU logique sur lequel le thread s’exécute actuellement.
Pratique pour vérifier le résultat après un sched_setaffinity.
🧩 Exemple :
printf("Thread en cours sur CPU %d\n", sched_getcpu());
1. Qu’est-ce que GkrellM ?
🧩 GkrellM (GNU Krell Monitors) est un outil de monitoring système graphique pour Linux et
UNIX.
Il affiche en temps réel l’état du système dans une interface verticale compacte : CPU, mémoire,
disque, réseau, capteurs, etc.
Catégorie Informations affichées Détails
Processeurs Permet de voir le nombre de cœurs logiques →
Charge par cœur
(CPU) utile pour observer hyperthreading
Mémoire RAM utilisée / libre, swap Barres de progression en temps réel
Système de Espace utilisé sur chaque
Ex. /, /home, /tmp, etc.
fichiers partition
Réseau Débit entrant / sortant Graphique de bande passante
Capteurs (si Températures, vitesses de
Nécessite le paquet lm-sensors
supportés) ventilateurs
Nombre de processus
Processus Peut afficher l’uptime et la charge moyenne
actifs