Archi Processus

Identification

Infoforall

23 - Gestion des processus


Cette activité va me demander une mise à jour, surtout de la partie algorithme d'ordonnancement. Ecrite sous une forte contrainte de temps, elle contient pas mal de choses fausses par manque de clarté finalement.

H'ai coupé la partie sur l'algo OTHER et l'activité perd du coup en cohérence : elle ne distingue plus clairement temps partagé et temps réel, ne mettant pas en avant le fait que RR et LIFO sont bien des algos à temps réel, même s'ils ne supportent pas les fortes contraintes "temps réel".

Bref, passez votre chemin pour l'instant. Cette activité n'est vraiment pas top.

Cette activité traite de questions assez importantes qui ont été mises de côté jusqu'à présent :

  • qu'est-ce qu'un processus par rapport à un programme ?
  • comment démarre un processus ?
  • comment l'ordinateur parvient-il à gérer plusieurs processus en même temps ?
  • pourquoi certaines applications se figent-elles définitement parfois ?
  • que viennent faire des zombis dans un cours de NSI ?
Image CC-BY-NC-SA https://turnoff.us

Evaluation ✎ : -

Documents de cours : open document ou pdf

1 - Vocabulaire : Programme, processus et processeur

Programme

Un programme est un ensemble d'instructions permettant de faire réaliser certaines tâches à un système informatique. Il s'agit donc d'une implémentation en machine d'un algorithme (algorithme qui peut lui être vu comme l'idée abstraite de l'action à accomplir).

En réalité, derrière ce mot "programme" se trouve deux notions :

  • Un programme binaire (ou langage machine) :
    • Il s'agit d'une suite de bits directement compréhensible par le processeur.
    • Exemple d'un ensemble de bits permettant de transférer le contenu d'une zone-mémoire dans l'un des registres de processeur :
      • En base 02 :  0010 0010 0011 1001 0000 0000 0000 0000 0000 0000 0010 0000 
      • En base 16 :  2239 0000 0020h  en utilisant la méthode des quartets
      • On peut le traduire si on sait qu'il s'agit du jeu d'instructions 68000 de Motorola, on peut lire dans la notice que  001  en début d'instruction signifie qu'on veut déplacer des données en mémoire (dont on donne l'adresse) vers un registre.
      • La traduction mot à mot en utilisant quelques mots clés plutôt que les valeurs réelles des bits se nomme le langage d'assemblage, ou assembleur par abus de langage.
  • Un programme source (ou code source) :
    • Il s'agit des instructions fournies dans un langage de programmation.
    • Ce code-source est compréhensible par un humain.
    • Ce code-source n'est pas compréhensible par le processeur d'un système informatique et doit être traduit en langage machine.
    • Voyons deux manières de gérer cette traduction :
      • les langages compilés (comme le langage C par exemple)
        • En première approximation, on peut le voir comme le fait de fournir le code-source à un compilateur qui va transformer le transformer en "code-machine". On transmet directement le "code-machine".
        • Avantages : rapidité (la traduction est déjà faite en grande partie) et la personne n'a pas d'autres programmes à installer sur sa machine.
        • Désavantages : le "code-machine" créé n'est compréhensible que par les systèmes d'exploitation et processeurs compatibles, compilation à faire à chaque fois qu'on veut vérifier le programme
      • les langages interprétés (comme le langage Python par exemple)
      • En première approximation, on peut le voir comme le fait de fournir le code-source à un interpréteur qui va transformer le code-source à la volée en code-machine. On transmet le code-source.
      • Avantages : le code-source est traduit directement par l'interpréteur du système sur lequel il doit tourner et va donc être compatible (sauf si le code-source utilise certaines spécificités de l'OS par exemple). La mise au point du programme est rapide puisqu'on peut le tester rapidement sans passer par la phase compilation.
      • Désavantages : c'est souvent lent (la traduction doit être faite en grande partie à la volée) et la personne doit avoir un interpréteur installé sur sa machine.
    Processeur

    Le processeur est composé principalement des parties suivantes :

    • L'UDC (Unité de Commande) permettant de gérer X bits à la fois : la partie de la puce qui lit la prochaine tâche élémentaire à effectuer en mémoire et qui commande l'UAL pour effectuer cette tâche élémentaire.
    • L'UAL (Unité Arithmétique et Logique) permettant de traiter X bits à la fois : la partie de la puce qui effectue les calculs, les déplacements en mémoire...
    • Quelques registres permettent de stocker et lire très rapidement en mémoire
    • Des bus permettant de transporter X bits à la fois

    On nomme cela UCT (Unité Centrale de Traitement en français) ou CPU (Central Processing Unit en anglais).

    Création d'un processus

    Que se passe-t-il lorsqu'on veut exécuter un programme ?

    Sachant que le programme n'est qu'une suite d'octets placés en mémoire de masse (disque dur, disque SSD, clé USB...), on va devoir :

    1. réserver une place spécifique en mémoire vive (RAM) (on parle de virtualisation de la mémoire)
    2. copier le code du programme en mémoire vive (RAM)
    3. commençer à gérer l'exécution du code du processus

    Un processus est donc l'exécution concrète d'un programme par le processeur à partir d'une zone mémoire virtuelle propre à ce processus.

    On dit également qu'un processus est une instance d'un programme : le programme est bien le moule permettant de générer le processus. Cette façon de voir les choses montrent bien qu'on peut lancer deux fois un même programme : on obtient en réalité deux instances, deux processus différents, disposant chacun de sa propre zone mémoire.

    Les mots "tâches" et "processus" sont équivalents.

    01° Qu'est-ce qui limite concrétement le nombre de processus pouvant être lancer en même temps ?

    ...CORRECTION...

    La place en RAM.

    Dès que la place est pleine, cela va énormément ralentir l'ordinateur : il est obligé de faire des copier-coller réguliers des données et des instructions entre la RAM et la mémoire de masse (qui est beaucoup plus lente).

    02° Qu'est-ce qu'un système d'exploitation multitâche ?

    ...CORRECTION...

    Un système d'exploitation qui sait faire fonctionner plusieurs processus "en même temps".

    03° Que va devoir faire un système d'exploitation multitâche lorsque plusieurs processus fonctionnent "en même temps" sur un ordinateur ne disposant que d'un seul microprocesseur (un coeur) ?

    ...CORRECTION...

    Le système d'exploitation va devoir choisir à qui offir les services du processeur.

    04° Que se passe-t-il au démarrage de l'ordinateur ?

    ...CORRECTION...

    Un premier programme bien spécifique est placé en mémoire automatiquement pour en faire le premier processus au démarrage.

    Premier démarrage : le chargeur d’amorçage

    Lorsqu'on démarre un système informatique, il est conçu pour générer automatiquement un premier processus en allant chercher un programme dans une zone précise de la mémoire : le chargeur d'amorçage ou bootloader en anglais.

    Ce processus va alors déclencher tous un tas d'autres processus : ceux permettant le démarrage du système d'exploitation par exemple.

    Les démons (daemons en anglais)

    Il s'agit d'une catégorie particulière de processus : des processus qui tournent en boucle car ils surveillent spécifiquement certaines choses.

    Leurs noms finissent souvent par ...d.

    Exemples :

    • httpd : le processus d'un serveur HTTP
    • crond : le processus du planificateur de tâches Cron (pour Chrono Table) de Linux (et Unix)
    Et une application ?

    Une application peut être vue comme étant un ensemble de processus produisant un effet commun.

    La plupart des applications réelles ne sont pas modélisables comme un seul processus : on encapsule certaines de leurs fonctions dans des processus indépendants discutant entre eux en utilisant des signaux, de la mémoire partagée, ou des tubes.

    2 - Etats du processus

    Voyons maintenant le cycle de vie d'un processus.

    Etats d'un processus

    Le programme est initialement en mémoire.

    On commence par l'état initialisé : on réserve de la place en mémoire vive, on copie le code...

    Le processus passe alors automatiquement à l'état PRET : il est prêt à faire exécuter sa prochaine instruction élémentaire au processeur. Mais pour l'instant, il n'y a pas accès.

    Le système d'exploitation va alors élire le prochain processus pouvant accéder au processeur : l'élection.

    Le processus passe à l'état ELU s'il remporte l'élection : ce sont ses instructions qui vont être traitées par le processeur.

    Trois situations alors :

    1. Le processus n'a plus d'instructions à traiter : il passe à l'état FINI (ZOMBI). Il n'est pas encore mort, mais ça ne devrait pas tarder.
    2. Le processus est en attente d'une réponse d'une ressource ou d'une entrée : il passe à l'état BLOQUE.
    3. Le processeur a décidé de donner l'accès à un autre processus : il passe à l'état PRET.

    Le processus passe à l'état BLOQUE.

    Il pourra revenir à l'état PRET lorsque le système aura reçu la ressource qu'il attend pour ce processus.

    05° Quels sont les états pendant lesquels la mémoire vive réserve de la place au processeur ?

    ...CORRECTION...

    Dans les 5 états.

    Dans le premier état, le processus vient de gagner sa place mémoire.

    Dans les 3 blancs (PRET - ELU - BLOQUE), il est en cours de traitement.

    Dans le dernier (FINI/ZOMBIE), il n'est pas encore mort. La mémoire est libérée en partie mais pas entièrement : nous allons voir que le processus qui l'a créé va venir récolter quelques dernières informations (comme une réponse par exemple) afin de le supprimer définitivement.

    Gestionnaire d'interruption

    Si on se limitait à cela, un processus n'aura pas son mot à dire en étant à l'état BLOQUE ou PRET. Il devrait tranquillement attendre son tour même si un événement important survenait pour lui.

    Imaginons qu'on veuille émettre un bip lorsqu'on tape sur une touche. Si le processus pouvant faire cela est en PRET ou BLOQUE, il ne pourrait rien faire tant que le processeur ne lui permette pas de continuer son exécution. D'ailleurs, le processus ne serait même pas au courant de l'appui sur la touche.

    Les systèmes d'exploitation intégrent donc un système de gestion d'interruption : un processus peut signaler qu'il doit effectuer des actions si un certain événement apparaît, on peut surveiller qu'une ressource finit par répondre à un appel provoqué par le processus...

    Le système d'exploitation peut alors interrompre le fonctionnement du processeur et provoquer une nouvelle élection.

    L'une des interruptions est d'ailleurs l'interruption d'horloge qui permet de provoquer périodiquement une nouvelle élection.

    3 - Linux

    Commande ps (process status) - introduction

    La commande ps permet d'obtenir la liste des processus actifs dans un terminal Linux (ici en utilisant la "simulation" de terminal, l'application graphique bash en réalité).

    rv@rv-HP2:~$ ps PID TTY TIME CMD 17255 pts/1 00:00:00 bash 18060 pts/1 00:00:00 ps

    Cette commande donne plusieurs informations sur les processus actifs :

    • PID : le numéro d'identification du processus dans le système d'exploitation. PID veut dire Process IDentifier. Sous Linux, c'est un entier naturel encodé sous 32 bits.
    • TTY : le terminal ou son équivalent application graphique qui "contrôle" le processus. Si le processus est un démon non rattaché à un terminal, vous verriez "?".
    • TIME : fournit le temps d'utilisation du CPU par ce processus. Attention, il s'agit bien du temps d'utilisation du processus : si on active Blender via le bash, le temps d'utilisation sera attribué à Blender : le Bash n'a servi qu'à lancer le processus de Blender.
    • CMD : la commande qui a engendré la création du processus.

    La commande ps est similaire à la commande tasklist de Microsoft Windows. Dans Windows PowerShell, ps est un alias pré-défini de la commande Get-Process qui a globalement la même fonction.

    06° Lancer Blender de cette façon via le bash. Gardez-vous la main sur le bash tant que Blender reste ouvert ?

    rv@rv-HP2:~$ blender

    ...CORRECTION...

    Non, nous n'avons plus la main sur le terminal tant que Blender est en route.

    07° Stopper Blender à l'aide de son interface graphique. Retaper ensuite un appel à Blender mais en rajoutant un &. Que constate-t-on au niveau du bash ? A quoi sert le rajout de &?

    Saved session recovery to '/tmp/quit.blend' Blender quit rv@rv-HP2:~$ blender & [1] 19369 rv@rv-HP2:~$

    ...CORRECTION...

    Cette fois, on peut encore taper des instructions dans le bash des informations sont apparues après l'appel de Blender.

    & permet de faire fonctionner plusieurs choses en même temps : le bash peut ainsi fonctionner "en même temps" que le processus qu'il a créé.

    08° Nouvelle commande ps. A quoi correspondent les informations que nous avions sous l'appel de Blender ?

    rv@rv-HP2:~$ blender & [1] 19369 rv@rv-HP2:~$ ps PID TTY TIME CMD 17255 pts/1 00:00:00 bash 19369 pts/1 00:00:37 blender 19883 pts/1 00:00:00 ps

    ...CORRECTION...

    Nous obtenons le PID qui a été attribué à Blender.

    rv@rv-HP2:~$ blender & [1] 19369 rv@rv-HP2:~$ ps PID TTY TIME CMD 17255 pts/1 00:00:00 bash 19369 pts/1 00:00:37 blender 19883 pts/1 00:00:00 ps

    09° Fermer le bash sans fermer Blender. Que constate-t-on ?

    ...CORRECTION...

    Cela a fermé Blender tout seul !

    Vous venez de voir qu'il y a un lien entre les deux programmes : la fermeture du bash a provoqué la fermeture de Blender.

    On peut donc dire que le bash est le père de Blender. Nous allons retrouver les Arbres !

    Observer l'arbre des processus avec pstree

    Voici un exemple de hierarchie qu'on peut observer sur les processus qui lance d'autres processus :

    On peut ouvrir un nouveau terminal et utiliser ceci :

    rv@rv-HP2:~$ ps PID TTY TIME CMD 20552 pts/1 00:00:00 bash 20562 pts/1 00:00:00 ps rv@rv-HP2:~$ blender & [1] 20563 rv@rv-HP2:~$ pstree systemd─┬─ModemManager───2*[{ModemManager}] ├─NetworkManager───2*[{NetworkManager}] ├─accounts-daemon───2*[{accounts-daemon}] ├─acpid ├─avahi-daemon───avahi-daemon ├─bluetoothd ├─colord───2*[{colord}] ├─cron ├─cups-browsed───2*[{cups-browsed}] ├─cupsd ├─dbus-daemon ├─dnsmasq───dnsmasq ├─fwupd───4*[{fwupd}] ├─gdm3─┬─gdm-session-wor─┬─gdm-x-session─┬─Xorg───20*[{Xorg}] │ │ │ ├─gnome-session-b─┬─ssh-agent │ │ │ │ └─2*[{gnome-+ │ │ │ └─2*[{gdm-x-session}] │ │ └─2*[{gdm-session-wor}] │ └─2*[{gdm3}] ├─gnome-keyring-d─┬─ssh-agent │ └─3*[{gnome-keyring-d}] ├─irqbalance───{irqbalance} ├─2*[kerneloops] ├─libvirtd───16*[{libvirtd}] ├─networkd-dispat ├─polkitd───2*[{polkitd}] ├─rsyslogd───3*[{rsyslogd}] ├─rtkit-daemon───2*[{rtkit-daemon}] ├─snapd───19*[{snapd}] ├─switcheroo-cont───2*[{switcheroo-cont}] ├─systemd─┬─(sd-pam) │ ├─at-spi-bus-laun─┬─dbus-daemon │ │ └─3*[{at-spi-bus-laun}] │ ├─at-spi2-registr───2*[{at-spi2-registr}] │ ├─atom─┬─atom───atom─┬─atom │ │ │ └─4*[{atom}] │ │ ├─atom───atom │ │ ├─atom───4*[{atom}] │ │ ├─atom───18*[{atom}] │ │ ├─atom───10*[{atom}] │ │ └─33*[{atom}] │ ├─dbus-daemon │ ├─dconf-service───2*[{dconf-service}] │ ├─2*[evince───5*[{evince}]] │ ├─evinced───2*[{evinced}] │ ├─evolution-addre───5*[{evolution-addre}] │ ├─evolution-calen───8*[{evolution-calen}] │ ├─evolution-sourc───3*[{evolution-sourc}] │ ├─firefox─┬─Privileged Cont───24*[{Privileged Cont}] │ │ ├─RDD Process───2*[{RDD Process}] │ │ ├─3*[Web Content───28*[{Web Content}]] │ │ ├─2*[Web Content───24*[{Web Content}]] │ │ ├─Web Content───29*[{Web Content}] │ │ ├─2*[Web Content───32*[{Web Content}]] │ │ ├─WebExtensions───24*[{WebExtensions}] │ │ └─106*[{firefox}] │ ├─gimp-2.10─┬─script-fu───2*[{script-fu}] │ │ └─7*[{gimp-2.10}] │ ├─gjs───6*[{gjs}] │ ├─gnome-session-b─┬─evolution-alarm───5*[{evolution-alarm}] │ │ ├─gsd-disk-utilit───2*[{gsd-disk-utilit}] │ │ ├─solaar───3*[{solaar}] │ │ ├─update-notifier───3*[{update-notifier}] │ │ └─3*[{gnome-session-b}] │ ├─gnome-session-c───{gnome-session-c} │ ├─gnome-shell─┬─evince───4*[{evince}] │ │ ├─ibus-daemon─┬─ibus-dconf───3*[{ibus-dconf}] │ │ │ ├─ibus-engine-sim───2*[{ibus-engi+ │ │ │ ├─ibus-extension-───3*[{ibus-exte+ │ │ │ └─2*[{ibus-daemon}] │ │ ├─notepadqq-bin───7*[{notepadqq-bin}] │ │ ├─oosplash─┬─soffice.bin───5*[{soffice.bin}] │ │ │ └─{oosplash} │ │ └─12*[{gnome-shell}] │ ├─gnome-shell-cal───5*[{gnome-shell-cal}] │ ├─gnome-terminal-─┬─bash───python───python───7*[{python}] │ │ ├─bash─┬─blender───20*[{blender}] │ │ │ └─pstree │ │ └─4*[{gnome-terminal-}] │ ├─goa-daemon───3*[{goa-daemon}] │ ├─goa-identity-se───2*[{goa-identity-se}] │ ├─gsd-a11y-settin───3*[{gsd-a11y-settin}] │ ├─gsd-color───3*[{gsd-color}] │ ├─gsd-datetime───3*[{gsd-datetime}] │ ├─gsd-housekeepin───3*[{gsd-housekeepin}] │ ├─gsd-keyboard───3*[{gsd-keyboard}] │ ├─gsd-media-keys───3*[{gsd-media-keys}] │ ├─gsd-power───3*[{gsd-power}] │ ├─gsd-print-notif───2*[{gsd-print-notif}] │ ├─gsd-printer───2*[{gsd-printer}] │ ├─gsd-rfkill───2*[{gsd-rfkill}] │ ├─gsd-screensaver───2*[{gsd-screensaver}] │ ├─gsd-sharing───3*[{gsd-sharing}] │ ├─gsd-smartcard───4*[{gsd-smartcard}] │ ├─gsd-sound───3*[{gsd-sound}] │ ├─gsd-wacom───2*[{gsd-wacom}] │ ├─gsd-xsettings───3*[{gsd-xsettings}] │ ├─gvfs-afc-volume───3*[{gvfs-afc-volume}] │ ├─gvfs-goa-volume───2*[{gvfs-goa-volume}] │ ├─gvfs-gphoto2-vo───2*[{gvfs-gphoto2-vo}] │ ├─gvfs-mtp-volume───2*[{gvfs-mtp-volume}] │ ├─gvfs-udisks2-vo───3*[{gvfs-udisks2-vo}] │ ├─gvfsd─┬─gvfsd-dnssd───2*[{gvfsd-dnssd}] │ │ ├─gvfsd-network───3*[{gvfsd-network}] │ │ ├─gvfsd-smb-brows───3*[{gvfsd-smb-brows}] │ │ ├─gvfsd-trash───2*[{gvfsd-trash}] │ │ └─2*[{gvfsd}] │ ├─gvfsd-fuse───5*[{gvfsd-fuse}] │ ├─gvfsd-metadata───2*[{gvfsd-metadata}] │ ├─ibus-portal───2*[{ibus-portal}] │ ├─ibus-x11───2*[{ibus-x11}] │ ├─nautilus───5*[{nautilus}] │ ├─pulseaudio───3*[{pulseaudio}] │ ├─sd_dummy───2*[{sd_dummy}] │ ├─sd_espeak-ng───4*[{sd_espeak-ng}] │ ├─snap-store───4*[{snap-store}] │ ├─speech-dispatch───2*[{speech-dispatch}] │ ├─tracker-miner-f───4*[{tracker-miner-f}] │ ├─xdg-document-po─┬─fusermount │ │ └─5*[{xdg-document-po}] │ └─xdg-permission-───2*[{xdg-permission-}] ├─systemd-journal ├─systemd-logind ├─systemd-machine ├─systemd-resolve ├─systemd-timesyn───{systemd-timesyn} ├─systemd-udevd ├─thermald───{thermald} ├─udisksd───4*[{udisksd}] ├─unattended-upgr───{unattended-upgr} ├─upowerd───2*[{upowerd}] ├─whoopsie───2*[{whoopsie}] └─wpa_supplicant rv@rv-HP2:~$

    Impressionnant non ?

    On peut aussi faire la même chose mais en affichant en plus les PID (résultat tronqué car trop long...).

    rv@rv-HP2:~$ pstree -p systemd(1)─┬─ModemManager(1064)─┬─{ModemManager}(1135) │ └─{ModemManager}(1139) ├─NetworkManager(922)─┬─{NetworkManager}(1038) │ └─{NetworkManager}(1063) ├─accounts-daemon(975)─┬─{accounts-daemon}(1009) │ └─{accounts-daemon}(1034) ├─systemd(1335)─┬─(sd-pam)(1336) │ ├─gnome-terminal-(3791)─┬─bash(3799)───python(3808)─+++ │ │ ├─bash(20552)─┬─blender(2056+ │ │ │ └─pstree(20927+ rv@rv-HP2:~$

    10° Qui est le père (nom et ID) du processus basé sur pstree ? A-t-il d'autres enfants (noms et PID éventuels) ?

    Qui est le processus-racine (celui qui n'a pas de parent) ? Quel est le PID de ce processus si particulier ?

    ...CORRECTION...

    Voici l'Arbre fortement simplifié :

    rv@rv-HP2:~$ pstree -p systemd(1)─┬─systemd(1335)─┬─(sd-pam)(1336) │ ├─gnome-terminal-(3791)─┬─bash(3799)───python(3808)─+++ │ │ ├─bash(20552)─┬─blender(2056+ │ │ │ └─pstree(20927+

    On voit que le processus-parent de pstree(PID 20927) est une instance de bash, l'instance bash(PID 20552).

    Le processus bash(PID 20552) a un autre enfant : blender(PID 2056).

    On remarque enfin que TOUS les processus sont des descendants d'un seul processus :

    Le processus systemd dont le PID est 1.

    Il finit en d car c'est un processus daemon/démon : il fonctionne en boucle.

    11° A votre avis, que va-t-il se passer si on tape ceci ?

    rv@rv-HP2:~$ kill 3791

    ...CORRECTION...

    Nous allons demander de tuer ce processus ce qui va provoquer la mort de tous ses descendants également.

    rv@rv-HP2:~$ kill 3791

    Comme toutes les commandes, pstree possède de multiples options. On peut par exemple afficher directement les parents d'un processus dont on connait le PID :

    rv@rv-HP2:~$ pstree -s 20563 systemd───systemd───gnome-terminal-───bash───blender───20*[{blender}]
    Commande ps (process status) - états des processus

    La commande ps permet d'obtenir la liste des processus actifs dans un terminal Linux.

    Vous devez savoir :

    • que les processus sont identifiés par un identifiant nommé PID.
    • Un processus est toujours l'enfant d'un autre processus, excepté pour les deux premiers d'entre eux qui servent de racine à leur propre arbre :
      • PID 1 : la racine init dans l'espace utilisateur.
      • PID 2 : la racine kthreadd dans l'espace noyau
    • A partir de ce moment, on ne peut créer un nouveau processus qu'en utilisant un appel système fork() qui va permettre de dupliquer le processus en cours, notamment toutes celles de l'environnement du processus parent. En modifiant ensuite ce processus pour rajouter le code du nouveau programme voulu, on peut créer un nouveau processus dépendant du processus père.
    • Chaque processus connait le PID de son parent. On le nomme PPID, comme Parent PID
    • Chaque processus connait le PID de ses enfants
    • Tuer un processus (avec kill PID ou juste via l'interface graphique) provoque la disparition également de tous les descendants du processus parent.

    La commande ps possède en réalité de très nombreuses options. On peut ainsi si on le veut visualiser le PID du processus ainsi que le PID de processus parent (celui qui a lancé ce processus).

    Pour obtenir de la description de la commande :

    rv@rv-HP2:~$ man ps

    Pour obtenir une liste avec pas mal d'informations :

    rv@rv-HP2:~$ ps aux USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 1 0.0 0.1 169288 12032 ? Ss 08:16 0:03 /sbin/init sp root 2 0.0 0.0 0 0 ? S 08:16 0:00 [kthreadd] systemd+ 809 0.0 0.1 25308 13280 ? Ss 08:16 0:05 /lib/systemd/ rv 1335 0.0 0.1 20448 10808 ? Ss 08:17 0:03 /lib/systemd/ rv 22334 0.7 0.0 15344 5956 pts/1 Ss 18:11 0:00 bash rv 22342 0.0 0.0 16928 4336 pts/1 R+ 18:11 0:00 ps aux
    • USER : l'utilisateur ayant généré le processus
    • PID : le numéro d'identification du processus
    • %CPU : % d'utilisation du CPU par ce processus
    • %MEM : % d'utilisation de la mémoire par ce processus
    • VSZ : donne l'utilisation des bibliotheques partagées et la memoire utilisé pour son fonctionnement
    • RSS : mémoire physique utilisée en kilobytes
    • TTY : le terminal contrôlant le processus
    • STAT : affiche l'état actuel du processus (voir plus bas)
    • START : heure à laquelle le procédure à démarrer
    • TIME : le temps d'utilisation du CPU par ce processus.
    • CMD : la commande qui a engendré la création du processus.

    Cette commande donne plusieurs informations sur les processus actifs :

    • PID : le numéro d'identification du processus dans le système d'exploitation. PID veut dire Process IDentifier. Sous Linux, c'est un entier naturel encodé sous 32 bits.
    • TTY : le terminal ou son équivalent application graphique qui "contrôle" le processus. Si le processus est un démon non rattaché à un terminal, vous verriez "?".
    • TIME : fournit le temps d'utilisation du CPU par ce processus. Attention, il s'agit bien du temps d'utilisation du processus : si on active Blender via le bash, le temps d'utilisation sera attribué à Blender : le Bash n'a servi qu'à lancer le processus de Blender.
    • CMD : la commande qui a engendré la création du processus.

    L'état des processus (STAT, comme Status) est ce qui nous intéresse ici :

    Les status possibles

    • R (Running et Runnable) : en cours d'exécution. Nous verrons que cela correspond aux états PRET (Runnable) ou ELU (Running) de la partie 2.
    • S (Sleeping) : endormi. Cela correspond à l'état BLOQUE de la partie 2.
    • D (Device) : en attente d'une ressource (généralement d'entrée/sortie) (le processus ne peut pas être interrompu). Cela correspond à l'état BLOQUE de la partie 2.
    • Les trois états terminaux FINI :

    • T (sTopped) : terminé et va transmettre sa réponse à son parent. On libère une partie de la mémoire mais on garde encore des informations sur son état final.
    • Z (Zombie) : processus terminé ayant répondu mais dont le parent n'a pas encore eu le temps de totalement finir la destruction.
    • X (Dead) : processus terminé et détruit (vous ne devriez jamais voir de X dans votre liste).

    On peut trouver une deuxième lettre derrière l'état : il s'agit de la priorité du processus :

    • < : Priorité haute
    • + : Processus au premier plan
    • s : Leader de session
    • l : multi-theads
    • N : Priorité basse
    • L : ressources verrouillées en mémoire

    12° Un processus doit disparaître. Il passe en STAT Z. Qui peut le faire passer à l'état STAT X ?

    ...CORRECTION...

    Son parent direct.

    On peut configurer ps pour lui faire afficher ce qu'on désire bien entendu.

    rv@rv-HP2:~$ ps -ef -o "user pid ppid stat start command" USER PID PPID STAT STARTED COMMAND rv 23006 3791 Ss+ 18:36:54 bash GJS_DEBUG_TOPICS=JS ERROR;JS LOG SSH_AUTH_SOCK=/run/use rv 22334 3791 Ss 18:11:15 bash GJS_DEBUG_TOPICS=JS ERROR;JS LOG SSH_AUTH_SOCK=/run/use rv 22990 22334 T 18:36:28 \_ python SHELL=/bin/bash SESSION_MANAGER=local/rv-HP2:@/tm rv 23435 22334 SLl 18:52:17 \_ blender SHELL=/bin/bash SESSION_MANAGER=local/rv-HP2:@/t rv 23498 22334 SLl 18:54:19 \_ blender SHELL=/bin/bash SESSION_MANAGER=local/rv-HP2:@/t rv 23672 22334 R+ 19:02:00 \_ ps -ef -o user pid ppid stat start command SHELL=/bin/ba rv 3799 3791 Ss 08:23:36 bash GJS_DEBUG_TOPICS=JS ERROR;JS LOG SSH_AUTH_SOCK=/run/use rv 3808 3799 S+ 08:23:53 \_ python manage.py runserver SHELL=/bin/bash SESSION_MANAG rv 9087 3808 Sl+ 11:27:21 \_ /home/rv/Envs/siteifa3/bin/python manage.py runserve rv 1498 1144 Ssl+ 08:17:22 /usr/libexec/gdm-x-session --run-script env GNOME_SHELL_SESS rv 1502 1498 Sl+ 08:17:22 \_ /usr/lib/xorg/Xorg vt2 -displayfd 3 -auth /run/user/1000 rv 1652 1498 Sl+ 08:17:43 \_ /usr/libexec/gnome-session-binary --systemd --session=ub

    On peut filtrer en cherchant les instances d'un programme spécifique.

    Un exemple où j'ai ouvert blender deux fois de suite pour avoir deux versions du programme à l'écran.

    rv@rv-HP2:~$ blender & [2] 23435 rv@rv-HP2:~$ blender & [3] 23498 rv@rv-HP2:~$ ps -fC blender UID PID PPID C STIME TTY TIME CMD rv 23435 22334 6 18:52 pts/1 00:00:08 blender rv 23498 22334 45 18:54 pts/1 00:00:02 blender

    13° Les deux instances de Blender ont-elles été créées à partir du même endroit ?

    ...CORRECTION...

    Oui car leur PPID est le même : ils ont le même parent.

    Activité publiée le 16 05 2021
    Dernière modification : 03 07 2021
    Auteur : ows. h.