4.2. Ordonnancement CPU
L'ordonnanceur est responsable de garder les CPU dans le système occupés. L'ordonnanceur Linux implémente un certain nombre de stratégies d'ordonnancement qui déterminent quand et pour combien de temps un thread est exécuté sur un cœur de CPU en particulier.
Les stratégies d'ordonnancement sont divisées en deux catégories majeures :
- Les stratégies en temps réel
- SCHED_FIFO
- SCHED_RR
- Les stratégies normales
- SCHED_OTHER
- SCHED_BATCH
- SCHED_IDLE
4.2.1. Stratégies d'ordonnancement en temps réel
Les threads en temps réel sont ordonnancés en premier et les threads normaux sont ordonnancés une fois que tous les threads en temps réel ont été ordonnancés.
Les stratégies en temps réel sont utilisées pour des tâches pour lesquelles le temps est critique, des tâches devant être effectuées sans interruption.
SCHED_FIFO- Cette stratégie est aussi appelée ordonnancement à priorité statique car elle définit une priorité fixe (de 1 à 99) pour chaque thread. L'ordonnanceur scanne une liste de threads SCHED_FIFO par ordre de priorité et programme le thread prêt avec la priorité plus élevée pour exécution. Ce thread est exécuté jusqu'à ce qu'il se bloque, qu'il échoue, ou qu'il soit préempté par un thread de plus haute priorité prêt à être exécuté.Même le thread en temps réel avec la plus basse priorité sera programmé avant tout thread possédant une stratégie qui n'est pas en temps réel, s'il n'existe qu'un seul thread en temps réel, la valeur de la priorité
SCHED_FIFOn'importe pas. SCHED_RR- Variante round-robin (tourniquet) de la stratégie
SCHED_FIFO. Les threadsSCHED_RRse voient aussi donner une priorité fixe entre 1 et 99. Cependant, les threads avec la même priorité sont programmés de manière round-robin (ou comme un tourniquet) avec un certain quantum, ou tranche, de temps. L'appel systèmesched_rr_get_interval(2)retourne la valeur de la tranche de temps, mais la durée de la tranche de temps ne peut pas être définie par un utilisateur. Cette stratégie est utile si vous avez besoin que de multiples threads soient exécutés avec la même priorité.
Pour obtenir des informations plus détaillées sur les sémantiques définies des stratégies d'ordonnancement en temps réel, veuillez consulter le standard POSIX IEEE 1003.1 disponible sous « System Interfaces — Realtime », qui se trouve sur http://pubs.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_08.html.
La meilleure manière de définir la priorité des threads est de commencer par les plus faibles priorités et d'augmenter uniquement lorsqu'une latence légitime est identifiée. Les threads en temps réel ne possèdent pas de tranches de temps comme les threads normaux. Les threads
SCHED_FIFO sont exécutés jusqu'à ce qu'il soient bloqués, qu'ils échouent, ou qu'ils soient préemptés par un thread possédant une priorité plus élevée. Ainsi, définir une priorité de 99 n'est pas recommandé, cela placerait votre processus au même niveau de priorité que des threads de migration et de surveillance. Si ces threads sont bloqués parce que votre thread se retrouve dans une boucle de calcul, ils ne pourront pas être exécutés. Les systèmes à monoprocesseur se retrouveront éventuellement dans une telle situation.
Dans le noyau Linux, la stratégie
SCHED_FIFO inclut un mécanisme de limite de bande passante. Cela protège les programmeurs d'applications en temps réel des tâches en temps réel qui pourraient monopoliser le CPU. Ce mécanisme peut être ajusté via les paramètres du système de fichiers /proc suivants :
/proc/sys/kernel/sched_rt_period_us- Définit la période de temps devant être considérée comme cent pour cent de la bande passante du CPU, en microsecondes (« us » est le plus proche équivalent de « µs » en texte brut). La valeur par défaut est 1000000µs, ou 1 seconde.
/proc/sys/kernel/sched_rt_runtime_us- Définit la période de temps devant être dévouée à l'exécution de threads en temps réel, en microsecondes (« us » est le plus proche équivalent de « µs » en texte brut). La valeur par défaut est 950000µs, ou 0.95 secondes.
