• Utilization su processur sur Micro: bit
• Processus en Linux

Pendant ce TP on va utiliser une machine virtuelle avec une interface graphique pour pouvoir utiliser plusieurs terminaux.

• basic.show_number (value) - exécute le nombre donné à l'écran en tant que paramètre; value peut également être une variable, qui stocke un nombre
• basic.show_string (value) - exécute à l'écran la chaîne donnée en tant que paramètre
• basic.show_icon (IconNames. nameIcon ) - affiche l'icône donnée à l'écran en tant que paramètre (les icônes sont l'équivalent des images utilisées dans les laboratoires précédents)
• basic.show_leds (leds: str, interval: int32) - leds est une chaîne qui contrôle quelle led est allumée ou éteinte; . signifie désactivé et # signifie désactivé
• basic.clear_screen () - règle toutes les LED sur la luminosité 0
• basic.pause (value) - est l'équivalent de la méthode sleep ; la valeur est exprimée en millisecondes

• input.on_button_pressed (Button.B, on_button_pressed_b) - vérifier si le bouton est enfoncé
• input.on_gesture (geste: geste, corps) - enregistre les gestes; geste peut prendre le logo de valeur vers le haut, le logo vers le bas, l'écran vers le haut, l'écran vers le bas, l'inclinaison vers la gauche, l'inclinaison vers la droite, la chute libre, 3g ou 6g.
• input.temperature () - mesure la température dans la pièce
• input.light_level () - mesure le niveau de luminosité dans la pièce

• led.toggle (x: number, y: number) - amène la LED à l'état opposé (si la LED est allumée, l'éteint, et si elle est éteinte, l'allume); x et y sont les coordonnées de la matrice de 25 LED, elles peuvent prendre des valeurs comprises entre 0 et 4
• led.brightness () - renvoie un nombre qui réinitialise le niveau de luminosité de l'écran LED, peut avoir des valeurs comprises entre 0 et 225

• music.play_tone (fréquence: nombre, ms: nombre) - fréquence représente le nombre de Hertz de la tonalité, et ms la durée en millisecondes du son

Le module control a des fonctions qui permettent aux tâches de s'exécuter en parallèle et l'interaction entre eux.

La fonction in_background (fun) reçoit une fonction comme paramètre et l'exécute en même temps que le programme principal.

Exécutez l'application suivante et observez le résultat obtenu. Quand la fonction du background s'exécute-t-elle? Pourquoi?

def background_task():
    for i in range(10):
        print (i)
control.in_background(background_task)
for i in range (20,30)
    print (i)

Modifiez le programme pour exécuter la fonction background_task.

Lorsque on presse sur le bouton a sur l'affichage de la plaque, la température s'affichera et, comme on veut simuler deux processus, un son se produit en arrière-plan/ backgorund. Pour tester l'exemple ci-dessous, cliquez sur ici.

def on_in_background(): 
    while True:
        music.play_tone(Note.C, music.beat(BeatFraction.QUARTER))
control.in_background(on_in_background)
 
def on_button_pressed_a():
    temp = input.temperature()
    basic.show_number(temp)
    basic.pause(100)
input.on_button_pressed(Button.A, on_button_pressed_a)

Pour faire la communication entre le programme principal et la tâche du background, nous avons deux fonctions:

• control.raise_event (source, value) - émet un événement depuis la source (source entiere) avec la valeur value
• control.event_value () - retourne la valeur du dernier événement émis

le program suivante génère une tâche qui émet la valeur 2.

def background_task():
    control.raise_event(1,2)
control.in_background(background_task)
pause (1000)
print (control.event_value())

1. Créez un programme qui fait clignoter une LED une fois par seconde en background, dans le programme principal on va afficher le niveau de lumière une fois toutes les 5 secondes.
2. Créez un programme qui fait deux LEDs clignoter concomitant en utilisant des tâches en background.
3. Créez un programme qui lit la valeur de la lumière toutes les 2 secondes en backgound et l'affiche dans le programme principal.
4. Lisez de la fonction control.on_event() et implémentez les deux exercices précédents en utilisant cette fonction.
5. Utilisez la fonction control.on_event() pour créer un programme qui allume la LED (0,0) lorsque la température dépasse 15 degrés Celsius et allume la LED (4,4) lorsque la lumière dépasse une certain température défini par vous.
6. Créez un programme dans lequel la LED (0,0) clignote une fois par seconde jusqu'à un bouton soit appuyee en utilisant de tâches en background.
7. Créez un programme qui utilise des événements pour afficher la température chaque fois que vous appuyez sur le bouton a et le niveu de lumiere chaque fois que vous appuyez sur le bouton b.

Pour ouvrir un nouveau terminal:

Vous pouvez utiliser les raccourcis suivants dans le terminal:

Pour faire naviguer dans un terminal, en particulier lorsqu'une commande affiche beaucoup de texte, utilisez les raccourcis suivants:

Autres raccourcis:

Lancer une application signifie allouer des ressources système (processeur, mémoire, périphériques d'entrée / sortie) pour exécuter l'application. Une application qui s'exécute, c'est-à-dire utilise des ressources système pour exécuter du code et traiter des données, est appelée un processus. Lorsque nous démarrons une application, un processus est créé; lorsque nous arrêtons l'application, ou lorsqu'elle termine son exécution, nous entendons la fin de l'exécution du processus.

Le processus démarre à partir d'un fichier exécutable contenant le code de l'application (instructions) et les données. Le fichier exécutable est également appelé image du processus . Le fichier exécutable est un programme. Nous disons que le processus est un programme en cours d'exécution.

Un système d'exploitation a généralement plus d'applications en cours d'exécution, donc plus de processus. Un trop grand nombre de processus peut declancher une surcharge du système, ralentir son fonctionnement. Certains processus peuvent consommer des ressources excessives affectant d'autres processus. Par conséquent, il est utile d'étudier les processus d'un système et leur consommation de ressources.

A un niveau plutôt didactique, on peut visualiser la liste des processus d'un système. L'utilitaire ps affiche les processus courantes dans le système (un snapshot des processus du système). Sur une simple exécution, l'utilitaire ps affiche les processus dans le terminal courant:

student@uso:~$ ps
  PID TTY          TIME CMD
14897 pts/4    00:00:00 bash
14910 pts/4    00:00:00 ps

Dans le terminal actuel (indiqué par la colonne “TTY” à l'écran, c'est-à-dire le terminal pts /4), il y a deux processus:

1. le processus shell (bash) dans lequel nous exécutons des commandes qui créent de nouveaux processus;
2. le processus de listage ( ps ) que je viens de lancer avec la commande ps; il se montre pratiquement

Pour afficher tous les processus système, nous utilisons l'option -e (pour everything) de l'utilitaire ps comme dans la commande ci-dessous:

student@uso:~$ ps -e
  PID TTY          TIME CMD
    1 ?        00:00:19 systemd
    2 ?        00:00:00 kthreadd
    4 ?        00:00:00 kworker/0:0H
    6 ?        00:00:00 mm_percpu_wq
    7 ?        00:00:09 ksoftirqd/0
    8 ?        00:00:06 rcu_sched
    9 ?        00:00:00 rcu_bh
   10 ?        00:00:00 migration/0
   11 ?        00:00:00 watchdog/0
[...]

Un processus est créé par un autre processus. Par exemple, ci-dessus, le processus ps a été créé à partir d'un processus shell (bash). Le processus shell a été à son tour créé par un autre processus. Un processus a un processus parent; un processus peut avoir plusieurs processus enfants. Les processus font partie d'une hiérarchie.

Pour visualiser lhiérarchie on va utliser pstree:

student@uso:~$ pstree
systemd-+-ModemManager---2*[{ModemManager}]
        |-NetworkManager-+-2*[dhclient]
        |                `-2*[{NetworkManager}]
        [...]
        |-acpid
        |-avahi-daemon---avahi-daemon
        |-boltd---2*[{boltd}]
        |-colord---2*[{colord}]
        |-cron
        [...]
        |-systemd-+-(sd-pam)
        |         |-gnome-terminal--+-bash
        |         |                 `-3*[{gnome-terminal-}]
        [...]

Au sommet de la hiérarchie des processus se trouve le processus appelé init classique. Dans la liste ci-dessus, nous voyons que le processus en haut de la hiérarchie est systemd. systemd est l'implémentation init présente dans la plupart des distributions Linux actuelles.

L'utilitaire ps a un affichage tabulaire des processus, chaque colonne correspondant à un attribut des processus. Sur une simple exécution, comme nous l'avons vu ci-dessus, quatre colonnes s'affichent:

• PID : représentant l'identifiant du processus
• TTY : le terminal dans lequel le processus s'exécute (apparaît? Pour un processus qui n'a pas de terminal - en général, les processus de type service, également appelés processus démons, n'ont pas de terminal)
• TIME : durée d'exécution du processeur (en heures, minutes, secondes)
• CMD : le nom de la mémoire image (c'est-à-dire le nom de l'exécutable / programme à partir duquel le processus a été créé)

PID ( Process Id ) est l'attribut essentiel du processus, un index qui identifie le processus au niveau du système. Un processus est identifié par PID et non par nom d'exécutable (CMD). Nous pouvons créer plusieurs processus à partir du même exécutable, chaque processus ayant son propre PID.

Pour vérifier l'existence de plusieurs processus, nous allons créer plusieurs processus shell. Pour commencer, nous ouvrons plusieurs sessions de terminal, en utilisant, par exemple, Alt+F2 dans l'environnement graphique et en entrant la commande “gnome-terminal” dans l'invite créée. Ensuite, nous ne visualisons que les processus créés à partir de l'exécutable bash en exécutant la commande:

student@sde:~$ ps -e | grep bash
 2181 pts/1    00:00:00 bash
 2194 pts/2    00:00:00 bash
 2205 pts/3    00:00:00 bash
14750 pts/0    00:00:00 bash
14897 pts/4    00:00:00 bash

Nous obtenons un résultat comme celui ci-dessus. Il existe cinq processus, tous créés à partir de l'exécutable bash, avec cinq PID différents: 2181, 2194, 2205, 14705, 14879.

Un processus a plus des quatre attributs affichés lors d'une seule exécution de l'utilitaire ps. Pour afficher plus d'attributs, utilisez l'option -f (à partir du format complet) ou l'option -F (à partir du format extra complet), comme ci-dessous:

student@uso:~$ ps -f
UID        PID  PPID  C STIME TTY          TIME CMD
student  14897 14896  0 17:12 pts/4    00:00:00 -bash
student  15026 14897  0 17:46 pts/4    00:00:00 ps -f
 
student@uso:~$ ps -F
UID        PID  PPID  C    SZ   RSS PSR STIME TTY          TIME CMD
student  14897 14896  0  6056  5136   0 17:12 pts/4    00:00:00 -bash
student  15027 14897  0  9728  3340   0 17:46 pts/4    00:00:00 ps -F

Bien sûr, nous pouvons combiner ces options avec l'option -e pour afficher tous les processus:

student@uso:~$ ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 Aug18 ?        00:00:19 /lib/systemd/systemd --system --deserialize 39
root         2     0  0 Aug18 ?        00:00:00 [kthreadd]
root         4     2  0 Aug18 ?        00:00:00 [kworker/0:0H]
root         6     2  0 Aug18 ?        00:00:00 [mm_percpu_wq]
root         7     2  0 Aug18 ?        00:00:09 [ksoftirqd/0]
root         8     2  0 Aug18 ?        00:00:06 [rcu_sched]
root         9     2  0 Aug18 ?        00:00:00 [rcu_bh]
root        10     2  0 Aug18 ?        00:00:00 [migration/0]
root        11     2  0 Aug18 ?        00:00:00 [watchdog/0]
[...]

Les options -f et -F affichent également d'autres attributs de processus, tels que:

• UID : le nom de l'utilisateur propriétaire du processus
• PPID : l'identifiant du processus parent
• C : pourcentage de processeur occupé
• STIME : heure de début
• RSS : RAM résidente

Ces attributs sont utiles pour voir quels processus consomment le plus de ressources (par exemple, processeur ou mémoire).

L'utilitaire ps affiche les processus et leurs attributs à un moment donné, un instantané des processus système. Nous nous intéressons souvent aussi à l'évolution des processus dans le temps: l'évolution de la consommation des ressources, l'émergence de nouveaux processus. Autrement dit, pour surveiller les processus.

De toute évidence, un moyen simple de surveiller est d'exécuter périodiquement l'utilitaire ps. Cependant, il existe des utilitaires de surveillance dédiés.

L'utilitaire top est l'utilitaire de base de surveillance de processus dans le monde Linux. C'est l'équivalent du Gestionnaire des tâches de Windows. L'exécution de “top” conduit à l'affichage, dans le terminal, des processus système et au rafraîchissement des informations périodiquement (par défaut 2 secondes). L'image ci-dessous est une fenêtre de terminal avec la partie supérieure en cours d'exécution:

top affiche des informations périodiques sur les processus et l'état du système: consommation du processeur, mémoire. À chaque période (2 secondes par défaut), les informations affichées sont actualisées.

Comme dans le cas de l'utilitaire less, la sortie de l'utilitaire supérieur se fait à l'aide de la touche q.

Un utilitaire similaire un peu plus convivial est l'utilitaire htop8). Comme dans le cas du haut, l'utilitaire htop s'exécute sur la ligne de commande en entrant la commande htop et démarre, dans le terminal, une fenêtre interactive, comme dans l'image ci-dessous:

“htop” est aussi un utilitaire interactif, un résumé des commandes utilisables est présenté dans la barre inférieure de sa fenêtre. Par exemple, comme nous le voyons dans l'image ci-dessus, avec la touche F6, nous pouvons choisir un attribut pour trier les processus.

Une fois démarré, un processus s'exécute et consomme des ressources système. Après avoir exécuté le code dans l'exécutable correspondant, le processus termine son exécution et libère les ressources consommées. Mais certains programmes (par exemple les serveurs) n'ont pas de point d'arrêt, mais s'exécutent en boucle, théoriquement à l'infini. De même, certains programmes (par exemple un navigateur Web) sont interactifs et ne terminent leur exécution qu'à l'action explicite de l'utilisateur.

Nous distinguons les types suivants d'arrêt d'un processus:

1. Le processus atteint la fin du code du programme et termine son exécution.
2. Un comportement inattendu ou une erreur dans le fonctionnement du programme provoque l'exécution de son exécution (crash).
3. L'utilisateur effectue une action interactive qui envoie la commande pour terminer l'exécution du processus: par exemple en utilisant la touche q pour terminer un processus top.
4. L'utilisateur ou le système d'exploitation décide qu'un processus ne fonctionne pas correctement et décide de le terminer.

Le dernier point de l'étape ci-dessus, également appelé fin d'un processus (ou, de manière informelle, tuer un processus) se fait, sous Linux, en utilisant signaux .

Pour mettre fin (tuer) de force un processus, nous utilisons des signaux. Un signal est une notification envoyée par un utilisateur ou un système d'exploitation à un processus. Il n'est pas obligatoire pour un signal de tuer le processus qui le reçoit, mais c'est le comportement le plus courant et l'utilisation principale des signaux.

Pour envoyer un signal à un processus, nous devons connaître son PID et utiliser l'utilitaire kill suivi du PID du processus. Autrement dit, si nous démarrons un processus de mise en veille dans un terminal à l'aide de la commande ci-dessous:

student@uso:~$ sleep 60

Dans autre terminal on va savoir son PID (en utilisant pidof)

student@uso:~$ pidof sleep
9486

et apres on va le touer (en utilsant kill)

student@uso:~$ kill 9486

La commande kill reçoit comme argument le PID du processus de mise à mort, 9486.

On verifie encore une fois si il y a un processus sleep en utilisant pidof:

student@uso:~$ pidof sleep
student@uso:~$

Nous voyons à partir de la sortie que le processus de sommeil n'existe plus, donc il a été tué.

Dans le terminal initial, où j'ai exécuté la commande sleep, un message apparaît indiquant que le processus a été tué:

student@uso:~$ sleep 60
Terminated

Dans certaines situations, l'utilisation de l'utilitaire kill ne tue pas le processus cible. Dans cette situation, nous enverrons le signal SIGKILL au processus cible qui est garanti pour tuer le processus. Je veux dire, drôle, SIGKILL est une bombe nucléaire, une balle qui traverse le gilet pare-balles, du cyanure de potassium. Ainsi, si nous démarrons un processus de veille sur un terminal comme ci-dessus, dans un autre terminal, nous tuerons le processus en utilisant le signal SIGKILL comme ci-dessous:

student@uso:~$ pidof sleep
9834
student@uso:~$ kill -KILL 9834
student@uso:~$ pidof sleep
student@uso:~$

La séquence de commandes est similaire à la séquence précédente sauf pour l'utilisation de l'option -KILL sur la commande kill qui signifie l'envoi du signal SIGKILL.

L'effet est similaire mais, sur le terminal où j'ai exécuté la commande sleep, un message apparaît sous la forme:

student@uso:~$ sleep 60
Killed

Le message Killed est affiche quand le processus recoi le signal SIGKILL.

1. Afficher tous les processus du système contenant des données en ce qui concerne le PID, le PID parent, l'utilisateur qui est le propriétaire du processus et la commande qui a démarré le processus.
2. Filtrer les processus par utilisateur actuel (student)
3. Afficher les processus de manière interactive (en utilisant top / htop)

• Élément de liste non ordonné Commencez dans trois terminaux différents trois processus de sommeil. Tuez-les tous avec une seule commande. Le PID du shell actuel peut être trouvé à l'aide de la commande:

student@uso:~$ echo $$
9477

• Tuez le shell actuel.
• Démarrez une application d'obturation. Démarrez une application libreoffice. Démarrez une application Firefox. Démarrez une application transmission-gtk. Tuez ces processus à l'aide de l'utilitaire kill.

Créez un fichier cpu_hog avec le contenu suivant:

#!/bin/bash
 
(
nohup dd if=/dev/zero of=/dev/null bs=8M > /dev/null 2>&1 &
)

Utilisez le script cpu_hog pour démarrer un processus qui utilise beacoup ressources du processeur. Vous le démarrez à l'aide d'une commande de la forme:

$ chmod +x cpu_hog
$ ./cpu_hog

Le script cpu_hog démarre un processus qui exécute une boucle infinie.

Observation, en utilisant la commande top, que le processeur est chargé. Identifiez le processus qui consomme le plus grand consomateur de ressources et tuez-lui. Notez, à l'aide de la commande top, que le processeur n'est plus chargé.

Solutions