Priorité des processus et affinité - Notion de priorité

Priorité des processus et affinité - Notion de priorité - version nouvelle

Sous Microsoft Windows, comme sous tous les systèmes d'exploitation multitache, de nombreux programmes semblent actifs simultanément. Dans la réalité, ce n'est pas du tout possible avec un seul processeur. Ca l'est devenu un peu depuis l'émergence des processeurs multi-cœurs (multi-cores) et de l'Hyper-Threading, depuis 2001 chez IBM, 2003 chez Sun, 2004 chez HP et 2005 chez Intel et AMD (les architectures x86 des PC).

En réalité, pour chaque processeur (chaque cœur), une seule tâche est accomplie à la fois. Cette apparence d'exécution en parallèle de plusieurs processus est obtenue en commutant rapidement d'un processus à l'autre (« commutation de contexte » - « context switching ») et en leur attribuant, à tour de rôle, une « tranche de temps » du processeur (ou d'un cœur). C'est la fonction d'« ordonnancement des processus » par « le grand ordonateur » (l'ordonnanceur).
).

Le cycle horloge (ou cycle CPU)

Le cycle horloge (ou cycle CPU) et le cadencement de l'exécution des instructions. La durée d'un cycle horloge est établie sur le temps d'exécution maximal possible de l'instruction la plus longue (la plus lente), ceci permettant d'être certain que lorsque l'instruction suivante est prise en charge, l'instruction précédente est bien terminée et ses résultats stabilisés. Comme le fait de caler le cycle horloge sur le temps le plus long pénalise l'ensemble des temps d'exécution des instructions plus brèves, des astuces sont mises en place comme découper les instructions longues en plusieurs étapes qui, selon leur nature et la faisabilité, s'exécuteront sur plusieurs cœurs simultanément ou sur plusieurs cycles CPU successifs, ceux-ci étant beaucoup plus courts et la capacité globale de traitement beaucoup plus importante.

L'algorithme de tourniquet (Round-Robin)

Une « tranche de temps » est un nombre de cycles horloge (cycles CPU). Ce découpage du temps en tranches est connu sous le nom de « Time slicing » permettant le « partage du temps » (le « Time sharing » ou « Temps partagé »).

• Une tâche qui est en attente (qui n'a pas besoin de temps) entre en mode d'attente (appelé « Idle ») et le dit au système qui passe alors la main à une autre tâche.
• Le fait qu'une tâche ait besoin de beaucoup de temps ne lui donne pas le droit de mobiliser la puissance de calcul à elle toute seule. Elle doit partager le temps avec les autres processus.

Le principe de cette distribution repose sur un algorithme de tourniquet (Round-Robin). Chaque tâche, dans l'ordre dans lequel elle est entrée dans la liste des tâches, a droit à un quantum de temps. Ce quantum de temps :

• Ne doit pas être trop court sinon il va y avoir une énorme quantité de temps perdu à faire des commutations de contexte (Context Switchings). Si un context switching prend 20 millisecondes et que le quantum de temps (la « tranche de temps ») allouée aux processus est de 20 millisecondes, toutes les 20 millisecondes le context switching va passer 20 millisecondes à sauvegarder le contexte (registre, mémoire cache L1 du processeur...) du processus qui quitte le processeur, et restaurer le contexte du processus qui y retourne. Dans un tel cas, l'ordinateur va allouer la moitié du temps aux processus réels de l'utilisateur et consommer l'autre moitié du temps (perdre du temps) pour ses propres besoins !
  
  
  
  Processus dans le tourniquet (Round-Robin)
  Priorité (temps de possession plus ou moins long d'un processeur par rapport à d'autres processus)
  Overhead (temps perdu) des contexts switching
  
  
  
• Ne doit pas être trop long sinon le/les processeurs vont être mobilisés pour rien. Si le quantum de temps (la « tranche de temps ») est d'une heure alors que l'application s'exécute en 30 secondes (elle a tout le temps, dès qu'elle « possède » l'ordinateur, de se terminer), nous ne sommes plus dans un système de partage de temps mais dans un système qui se rapproche des listes de type « Premier entré - Premier sorti » (« First In, First Out » - « FiFo »).

Si 50 processus sont dans la liste des processus, chaque processus possèdera le processeur 1 fois sur 50. Il est donc utile d'avoir le moins de processus actifs (ce qui se traduit, côté utilisateur de Windows, par :

• La fermeture de toutes les applications utilisateurs (toutes les fenêtres) qui n'ont pas besoin de rester actives
• La désinstallation de tous les bloatwares et inutilitaires
• Le nettoyage de la liste de démarrage de Windows

Dans la réalité, le choix du quantum se fait entre 10ms et 100ms selon diverses mesures statistiques du comportement des processus et afin que les pertes de temps, dont celles durestent contenues en dessous de 20% du temps total.

L'algorithme de tourniquet (Round-Robin) est pondéré par les niveaux de priorité :

Certains processus ont droit à plus de temps que d'autres (temps de possession plus ou moins long d'un processeur par rapport à d'autres processus). Cette pondération est introduite par un mécanisme de priorités plus ou moins élevées et le temps est réparti par l'ordonnanceur (« le grand ordonnateur »), la tâche d'ordonnancement des processus.

Windows reconnaît 6 niveaux de priorité :

1. Temps réel
2. Haute
3. Supérieure à la normale
4. Normale
5. Inférieure à la normale
6. Basse

Pour l'expliquer, en termes très simples (simplistes), utilisons des valeurs arbitraires faciles à manipuler intellectuellement et à comprendre :

• Une tranche de temps = 100 cycles horloges, soit l'exécution de cent instructions
• Chaque niveau de priorité est un multiple entier d'une tranche de temps

En fonction de son niveau de priorité, un processus a droit, avant d'être contraint, par l'ordonnanceur, de « passer la main », à :

Priorité	Temps alloué par la tâche d'ordonnancement des processus
Temps réel	6 tranches de temps (exécution de 600 instructions avant de rendre la main)
Haute	5 tranches de temps (exécution de 500 instructions avant de rendre la main)
Supérieure à la normale	4 tranches de temps (exécution de 400 instructions avant de rendre la main)
Normale	3 tranches de temps (exécution de 300 instructions avant de rendre la main)
Inférieure à la normale	2 tranches de temps (exécution de 200 instructions avant de rendre la main)
Basse	1 tranche de temps (exécution de 100 instructions avant de rendre la main)

Donc, modifier la priorité d'un processus consiste à lui allouer plus de temps processeur (et moins de context switching), donc une plus importante « rapidité apparente », comparativement aux autres processus. Ce n’est pas une accélération brute stricto sensu, c’est une accélération relative (relativement aux autres).

La vraie notion de « temps réel » est un peu différente. Dans Windows, on appelle « temps réel », par abus de langage, les applications à priorité très élevée – ce n’est pas parce qu’elles ont une priorité très élevée qu’elles deviennent « temps réel ». Le « temps réel » est la capacité d'un processus à demander et obtenir « la main » sur la survenance d'un événement (ou l'inverse : un système surveillant la survenance d'évènements donne immédiatement la main à du code approprié dès qu'un « drapeau » [un sémaphore] se lève quelque part).

• On le trouve dans les antivirus et anti-malware qui, sur la survenance de l'ouverture d'un fichier ou la montée en mémoire de quelque chose, prennent immédiatement la main pour bloquer l'action en cours et analyser ce qui se passe avant d'arbitrer. Ces applications disposent d'un « driver » (implanté en tant que « service de Windows », avec les privilèges du « ring 0 », et crochètent (hook) certains appels au système pour s’interposer, en temps réel.
• On le trouve dans les processus industriels. Ainsi, s’il n’y a plus de caramel pour napper les Twix droits (allusion à une publicité télévisuelle des années 2015/2017), une sonde (par exemple un faisceau lumineux qui ne sera plus coupé à cause de l'absence de matière) enverra un signal (0 ou 1 - on parle d'un « drapeau » ou « sémaphore ») à un système (une carte contrôleur d'acquisitions numériques dans un ordinateur) permettant de prendre, en temps réel, une décision sur survenance d'un événement. Un logiciel temps réel « préemptif » prendra les mesures qui s’imposent (arrêter la chaîne industrielle, etc.).
  SCADA (Supervisory Control And Data Acquisition - Système d'Acquisition et de Contrôle de Données).

En principe, toutes les applications d'un utilisateur normal sont en priorité normale.

Attention : Le fait de modifier les priorités et les affinités (affectation d'un cœur du processeur) de certains composants peut rendre un système totalement instable, voire le « planter » complètement. A manipuler avec précautions. De préférence, ne touchez à rien des composants de Windows et n'affectez à rien la priorité « temps réel ».