Ordonnancement de processus Introduction

Transcription

Ordonnancement de processus
•
Introduction
•
Niveaux d’ordonnancement
•
Objectifs d’ordonnancement
•
Politiques d’ordonnancement
•
Ordonnanceurs non préemptifs
•
Ordonnanceurs préemptifs
•
Etudes de cas
– Cas d’UNIX
– Cas de Linux
– Cas de Windows XP
– Implémentation : Ordonnanceur de Nachos
Systèmes d’exploitation
Génie Informatique
École Polytechnique de Montréal
Chapitre 7.1
Introduction
•
Les programmes lancés sont d’abord admis par le système qui se charge
d’en créer les processus nécessaires.
•
Dans un système multiprogrammé, plusieurs processus peuvent être
présents en mémoire centrale.
•
Le système d’exploitation décide de l’ordre et du moment de l’admission des
programmes en attente (ordonnanceur de haut niveau).
•
Il gère également l’allocation du processeur aux différents processus à
exécuter (ordonnanceur de bas niveau).
•
L’exécution d’un processus est une séquence alternée de calculs CPU
(rafales « burst ») et d’attentes d’événements (E/S, attente d’un
sémaphore..).
•
Lorsque le processus en cours se bloque, le processeur est alloué à un autre
=> L’ordonnanceur de bas niveau se charge des changements de contexte.
Génie Informatique
Chapitre 7.2
1
Programme A
Mode utilisateur
Introduction (2)
Commutation de contexte
Mode kernel
Programme B
Mode utilisateur
exécution
Sauvegarder état dans PCB A
exécution
Charger état de PCB B
Sauvegarder état en PCB B
Charger état de PCB A
exécution
•
Pour accélérer la commutation, certains processeurs sont dotés de deux ou
plusieurs groupes de registres.
Génie Informatique
Chapitre 7.3
Niveaux d’ordonnancement
Ordonnancement
Expiration
de haut niveau
Lot de travaux en attente d’admission
File d’attente, prêt
Ordonnancement
de bas niveau
Terminé
Process eur
Processeur
Ordonnancement
de niveau intermédiaire
File d’attente, prêt hors mémoire
Ordonnancement
de niveau intermédiaire
File d’attente, attente hors mémoire
Occurrence
File d’attente, attente d’événement
Attente d’événement
d’événement
Génie Informatique
Chapitre 7.4
2
Niveaux d’ordonnancement (2)
•
L’ordonnanceur de haut niveau décide du degré de la multiprogrammation (
nombre maximal de processus dans le système).
•
L’ordonnanceur de niveau intermédiaire gère le déplacement des processus
d’une file d’attente à une autre.
•
Dans la majorité des systèmes actuels, les niveaux intermédiaire et haut
sont combinés -> haut niveau.
•
L’ordonnanceur de bas niveau (dispatcher ou répartiteur) est sollicité
plusieurs fois par seconde et doit constamment résider en mémoire.
•
L’ordonnancement doit se faire selon une politique bien réfléchie visant à
répondre à des objectifs de performance.
Génie Informatique
Chapitre 7.5
Objectifs d’ordonnancement
1.
Maximiser le nombre de processus exécutés par unité de temps.
2.
Minimiser le temps d’attente d’exécution de chaque processus.
3.
Maximiser les temps d’utilisation des processeurs et autres ressources.
4.
Respecter les échéanciers (terminer l’exécution avant leurs deadlines).
5.
Éviter le problème de famine (attente infinie).
6.
Favoriser les processus les plus prioritaires (éviter le problème d’inversion des
priorités).
7.
Minimiser le nombre et la durée des changements de contexte.
Difficile de les satisfaire à la fois (exemple objectifs 1 et 4).
Prioriser les objectifs.
Génie Informatique
Chapitre 7.6
3
Objectifs d’ordonnancement (2)
Critères de performances
•
Temps de séjour d’un processus (temps de rotation ou de virement) : temps
entre l’admission du processus et sa sortie.
•
Temps d'
attente d’un processus : somme des périodes que le processus
passe à l'
état prêt
•
Temps de réponse: temps qui s'
écoule entre l'
entrée d'
un processus
et le moment où il commence à être traité
•
Capacité de traitement : nombre de processus traités par unité de temps.
•
Taux d’utilisation d’un processeur.
Génie Informatique
Chapitre 7.7
Politique d’ordonnancement
•
Choix du processus à exécuter ?
– Premier arrivé, premier servi.
– Plus prioritaire (priorités statiques ou dynamiques).
– Plus court temps ….
•
Le temps d’allocation du processeur au processus choisi :
– Allocation jusqu’à terminaison ou libération volontaire (ordonnanceur non
préemptifs).
– Temps d’allocation limité fixe ou variable (ordonnanceur préemptifs).
•
Quand appeler l’ordonnanceur ?
– Le processus en cours se termine, se bloque ou cède le processeur,
– Le temps alloué a expiré.
– L’arrivée d’un processus plus prioritaire…
Génie Informatique
Chapitre 7.8
4
Ordonnanceurs non préemptifs
(sans réquisition)
•
Le système d’exploitation choisit le prochain processus à exécuter :
– Premier arrivé, Premier servi (FCFS, First-Come First-Served) ou
– Plus court d’abord (SPF, Short Process First ou SJF Short Job First).
– Plus prioritaire d’abord (priorite = (temps d’attente + temps d’exécution) /
temps d’exécution).
•
Il lui alloue le processeur jusqu’à ce qu’il se termine, se bloque (en
attente d’un événement) ou cède le processeur. Il n’y a pas de
réquisition.
Génie Informatique
Chapitre 7.9
Ordonnanceurs non préemptifs (2)
FCFS
Processus
Exécution
Arrivée
A
3
0
B
6
1
C
4
4
D
2
6
E
1
7
AAABBBBBBCCCCDDE
Temps de séjour moyen : 7.6
Temps moyen d’attente : 4.4
Nombre de changements de contexte : 5
Remarque :
Temps moyen d’attente élevé si de longs processus sont exécutés en premier.
Génie Informatique
Chapitre 7.10
5
Short Processus First (SPF ou SJF)
Processus
Exécution
Arrivée
A
3
0
B
6
1
C
4
4
D
2
6
E
1
7
AAABBBBBBEDDCCCC
Temps de séjour moyen : 6.4
Remarque : Meilleur temps moyen d’attente.
Génie Informatique
Chapitre 7.11
SPF
•
Parmi les processus prêts, le processus élu est celui dont la prochaine
rafale est la plus courte.
Comment estimer le temps de la prochaine rafale ?
• Le temps de la prochaine rafale de chaque processus est estimé en se
basant sur le comportement passé du processus.
•
Soient Si et Ti les temps d’exécution estimé et mesuré pour la iième rafale,
les estimations successives sont :
S0 ;
pour la première
S1 = αT0 +(1- α )S0 ; pour la seconde
S2 = αT1 +(1- α )S1 ; pour la troisième
….
0≤α≤1
Génie Informatique
Chapitre 7.12
6
Ordonnanceur non préemptifs (5)
à priorité (éviter la famine)
•
•
•
•
Processus
Exécution
Arrivée
A
3
0
B
6
1
C
4
4
D
2
6
E
1
7
Priorité = (temps d’attente + temps d’exécution) / temps d’exécution
AAABBBBBBEDDCCCC
Le temps moyen de séjour : 6,4
Le temps moyen d’attente : 3,2
Génie Informatique
Chapitre 7.13
Ordonnanceurs avec réquisition
(préemptifs)
•
Pour s’assurer qu’aucun processus ne s’exécute pendant trop de temps, les
ordinateurs ont une horloge électronique qui génère périodiquement une
interruption.
•
A chaque interruption d’horloge, le système d’exploitation reprend la main et
décide si le processus courant doit :
– poursuivre son exécution ou
– être suspendu pour laisser place à un autre.
•
S’il décide de suspendre l’exécution au profit d’un autre, il doit d’abord
sauvegarder l’état des registres du processeur avant de charger dans les
registres les données du processus à lancer (commutation de contexte).
•
Cette sauvegarde est nécessaire pour pouvoir poursuivre ultérieurement
l’exécution du processus suspendu.
Génie Informatique
Chapitre 7.14
7
Ordonnanceurs avec réquisition (2)
(préemptifs)
•
Le processeur passe donc d’un processus à un autre en exécutant chaque
processus pendant quelques dizaines ou centaines de millisecondes.
•
Le temps d’allocation du processeur au processus est appelé quantum.
•
Cette commutation entre processus doit être rapide (temps nettement
inférieur au quantum).
•
Le processeur, à un instant donné, n’exécute réellement qu’un seul
processus.
•
Pendant une seconde, le processeur peut exécuter plusieurs processus et
donne ainsi l’impression de parallélisme (pseudo-parallélisme).
Génie Informatique
Chapitre 7.15
Ordonnanceurs préemptifs (3)
(Shortest Remaining Time SRT)
•
•
Lorsqu’un processus arrive, l’ordonnanceur compare le temps estimé de
son exécution avec celle du processus actuellement en exécution
(version préemptive du SPF).
Si ce temps est plus petit, on exécute immédiatement le nouveau
processus.
AAABCCCCEDDBBBBB
Processus
Exécution
Arrivée
A
3
0
B
6
1
C
4
4
D
2
6
E
1
7
Temps moyen de séjour : 5.8
Génie Informatique
Chapitre 7.16
8
Ordonnancement circulaire (Tourniquet ou round robin)
•
Algorithme ancien, simple, fiable et très utilisé.
•
Il mémorise dans une file (FIFO : First In First Out), la liste des
processus en attente d’exécution (prêts).
Génie Informatique
Chapitre 7.17
Ordonnancement circulaire
Choix de la valeur du quantum
• Algorithme équitable mais sensible au choix du quantum.
• Un quantum trop petit provoque trop de commutations de
processus et abaisse l’efficacité du processeur.
• Un quantum trop élevé augmente le temps de réponse des
courtes commandes en mode interactif.
• Il était de 1 seconde dans les premières versions d’UNIX.
• Il varie entre 20 et 120 ms.
Génie Informatique
Chapitre 7.18
9
Exemple 1
Quantum = 1
Temps de commutation = 0
Processus
Exécution
Arrivée
A
3
0
B
6
1
C
4
4
D
2
6
E
1
7
ABABACBDCEBDCBCB
Temps moyen de séjour : 8,0
Temps moyen d’attente : 4,8
Génie Informatique
Chapitre 7.19
Exemple 2
Quantum = 3 unités
Commutation de contexte = 1 unité
Processus
Exécution Arrivée
A
8
0
B
5(2)3
3
C
4
7
•
•
•
Le temps de séjour moyen : 21.33.
Le temps moyen d’attente : 14
Génie Informatique
Chapitre 7.20
10
Exemple 3
Quantum = 5 unités
Processus
Quantum = 5 unités
A A A A A
•
•
•
B B B B B
Exécution
Arrivée
A
8
0
B
5(2)3
3
C
4
4
C C C C
A A A
B B B
Le temps de séjour moyen : (21+22+13)/3 (soit 18,66).
Le temps d’attente moyen : 11,33.
Génie Informatique
Chapitre 7.21
Exemple 4
Processus
Exécution
Arrivée
A
8
0
B
5(2)3
3
C
4
4
CC C C
A
B B B
Quantum = 7 unités
Quantum = 7 unités
A A A A A A A
•
•
•
B B B B B
Le temps de séjour moyen : (21+22+15)/3 (soit 19.33).
Le temps d’attente moyen : 8.
Génie Informatique
Chapitre 7.22
11
Ordonnanceur à priorité avec files multiples
•
Il attribue une priorité à chaque processus (statique ou dynamique).
•
Les processus de même priorité sont dans une file FIFO
•
Il y a autant de files qu’il y a de niveaux de priorité
•
Les processus de chaque file sont ordonnancés selon l’algorithme du
Tourniquet (Round Robin avec un quantum variable ou fixe) ou FCFS.
Génie Informatique
Chapitre 7.23
Problèmes
• Équité : L’exécution des processus moins prioritaires peut
être constamment retardée par l’arrivée de processus plus
prioritaires.
• Inversion des priorités :
– un processus moins prioritaire détient une ressource nécessaire
à l’exécution d’un processus plus prioritaire.
– Le processus moins prioritaire ne peut pas s’exécuter car il y a
constamment des processus actifs plus prioritaires.
Génie Informatique
Chapitre 7.24
12
Attribution et évolution des priorités
•
Pour empêcher les processus de priorité élevée de s’exécuter indéfiniment,
l’ordonnanceur diminue régulièrement la priorité du processus en cours
d’exécution (priorité dynamique) et augmente progressivement celles des
processus en attente.
•
La priorité du processus en cours est comparée régulièrement à celle du
processus prêt le plus prioritaire (en tête de file). Lorsqu’elle devient
inférieure, la commutation a lieu.
•
Dans ce cas, le processus suspendu est inséré en queue de file
correspondant à sa nouvelle priorité.
•
Pour favoriser les processus qui font beaucoup d’E/S, ils doivent acquérir le
processeur dès qu’ils le demandent, afin de leur permettre de lancer leurs
requêtes suivantes d’E/S.
•
Pour éviter qu’il y ait beaucoup de commutations pour les processus
consommateurs de temps CPU, il est préférable d’allouer un plus grand
quantum à ces processus (quantum variable).
Génie Informatique
Chapitre 7.25
Etudes de cas
Génie Informatique
Chapitre 7.26
13
Cas d’UNIX (traditionnel)
•
C’est un ordonnanceur à deux niveaux. L’ordonnanceur de bas niveau se
charge d’élire un processus parmi ceux qui résident en mémoire.
•
L’ordonnanceur de haut niveau se charge des transferts de processus entre
la mémoire centrale et le disque.
•
L’ordonnanceur de bas niveau utilise plusieurs files, une priorité est
associée à chaque file (plusieurs niveaux de priorité).
•
Les processus prêts qui sont en mémoire, sont répartis dans les files selon
leur priorité.
•
Les priorités des processus s’exécutant en mode utilisateur sont positives
ou nulles, alors que celles des processus s’exécutant en mode noyau sont
négatives.
•
Les priorités négatives sont les plus élevées.
Génie Informatique
Chapitre 7.27
Cas d’UNIX (traditionnel) (2)
•
L’ordonnanceur de bas niveau choisit le processus le plus prioritaire
qui se trouve en tête de file.
•
Le processus élu est alors exécuté pendant au maximum un
quantum (100 ms). S’il ne se termine pas ou ne se bloque pas au
bout de ce quantum, il est suspendu.
•
Le processus suspendu est inséré en queue de sa file.
•
La priorité initiale d’un processus utilisateur est en général égale à
0. La commande nice permet d’attribuer une priorité plus basse à un
processus (>0).
•
Les priorités des processus prêts en mémoire sont recalculées
périodiquement toutes les secondes.
Génie Informatique
Chapitre 7.28
14
CAS d’UNIX (traditionnel) (3)
Génie Informatique
Chapitre 7.29
Cas de Linux
•
L’ordonnanceur de Linux est un ordonnanceur préemptifs et à priorité.
•
Il distingue trois classes de tâches (processus) qu’il ordonnance différemment:
– Processus FIFO temps réel (les plus prioritaires) : Aucun processus de
cette classe ne peut être interrompu par un autre, à moins que ce soit un
processus plus prioritaire de la même classe.
– Processus Tourniquet temps réel.
– Processus Temps partagé (les moins prioritaires) : Ils s’exécutent
uniquement si aucun processus des classes 1 et 2 n’est prêt.
•
Chaque processus créé fait partie d’une des trois classes et a une priorité
comprise entre 1 et 40 (20 par défaut).
•
Les valeurs élevées correspondent à des priorités élevées.
Génie Informatique
Chapitre 7.30
15
Cas de Linux (2)
•
Chaque processus de la deuxième et troisième classe a un Quantum : valeur
initiale = priorité.
•
Le Quantum du processus en cours d’exécution diminue de 1 unité à chaque
consommation de 10 ms de temps CPU.
•
Les quanta sont réajustés lorsque tous les processus sont bloqués ou leurs
quanta sont nuls : Quantum = Quantum / 2 + priorité
•
Lorsque l’ordonnanceur prend le contrôle, il attribue une note à chaque
processus :
Note = 1000 + priorité
si le processus appartient aux classes temps-réel
Note = Quantum >0 ? Quantum + priorité : 0
sinon
•
Le processus élu est celui qui a une plus forte note.
•
Le temps d’allocation du processeur est au plus égal à 10 fois son Quantum.
Génie Informatique
Chapitre 7.31
Cas de Linux (3)
Répéter
• Réajuster les quanta si tous les processus sont bloqués ou leurs
quanta sont nuls : Quantum = Quantum / 2 + priorité
•
Calculer la note de chaque processus prêt :
Note = 1000 + priorité
si le processus appartient aux classes temps-réel
Note = Quantum >0 ? Quantum + priorité : 0
•
sinon
Allouer le processeur à celui qui a la plus grande note (temps
d’allocation maximun est 10 fois son quantum).
Génie Informatique
Chapitre 7.32
16
Cas de Linux (4)
Exemple
•
•
•
Processus
Priorité
Exécution
A
20
160 (180) 70
B
18
40 (150) 140
C
10
300
A s'
exécute et s'
interrompt après 160 ms (40 ms non utilisées).
B s'
exécute et s'
interrompt après 40 ms (140 ms non utilisées).
C s'
exécute pendant 100 ms et est interrompu, A et B toujours bloqués.
Processus
Nouveau quantum
A
4/2+20 = 22
B
14/2+18 = 25
C
0/2 +10 = 10
Génie Informatique
Chapitre 7.33
Cas de Linux (5)
Exemple
•
Processus
Priorité
Exécution (ms)
A
20
160 (180) 70
B
18
40 (150) 140
C
10
300
C s'
exécute à nouveau et est interrompu (sa note est 0).
Processus
Note
Quantum
A
42
22
B
43
25
C
0
10
• B s'
exécute et se termine au bout de 140 ms (250-140 ms non utilisées).
• A s'
exécute et se termine au bout de 70 ms.
• C s’exécute et se termine au bout de 100 ms.
Génie Informatique
Chapitre 7.34
17
Cas de Windows XP
•
Windows XP ne contient pas un module autonome qui se charge de l’ordonnancement.
Le code est dispersé.
•
Il ordonnance les threads sans se préoccuper de leurs processus.
•
C’est un ordonnanceur préemptif à priorité (32 niveaux de priorité). Les priorités sont
dynamiques.
•
On distingue quatre classes de processus légers :
– Les threads temps réel : chaque thread de cette classe a une priorité comprise
entre 16 et 31. Sa priorité ne change jamais.
– Les threads utilisateur : chaque thread de cette classe a une priorité comprise
entre 1 et 15. Sa priorité varie durant sa vie mais reste toujours comprise entre 1 et
15. Il migre d’une file à une autre avec l’évolution de sa priorité.
– Le thread zéro (priorité 0) : il s’exécute, en arrière plan, lorsque toutes les files, de
priorité supérieure, sont vides. Il se charge de la remise à zéro des pages libérées.
– Le thread idle : il s’exécute si toutes les files sont vides.
Génie Informatique
Chapitre 7.35
Cas de Windows XP (2)
Génie Informatique
Chapitre 7.36
18
•
Les processus légers de même priorité sont dans une même file et ordonnancés
selon l’algorithme du tourniquet.
•
L’ordonnanceur est appelé si :
– Un thread passe à l’état prêt ou quitte l’état d’exécution.
– La priorité ou l’affinité de processeur d’un thread change.
•
L’ordonnanceur choisit le processus léger le plus prioritaire en tête de file et lui alloue
le processeur pendant au maximum un quantum.
•
Quand un processus léger est sélectionné, son exécution peut être interrompue
(avant la fin du quantum) si un autre processus léger de priorité plus élevée devient
prêt. Le thread préempté est remis en tête de la file associée à son niveau de
priorité.
•
Si un thread est suspendu car il a consommé son quantum, sa priorité peut être
diminuée.
•
S’il est interrompu pour une requête d’E/S, un sémaphore, etc., son quantum est
décrémenté par contre sa priorité augmente. Elle augmente encore plus, s’il s’agit
d’une requête d’E/S qui concerne un clavier ou un écran.
Génie Informatique
Chapitre 7.37
•
Si un thread à l’état prêt reste trop longtemps en attente du processeur (depuis 4
secondes environ), il se voit attribuer une priorité 15 et un quantum de 4 unités
(accélérer le threads pour éviter le problème de famine).
•
À la fin du quantum, le thread reprend sa priorité de base originale.
•
C’est le « balance set manager » qui se charge de la recherche de tels threads
(toutes les secondes).
•
Afin de minimiser le temps CPU consommé par le balance set manager, au
maximum 16 threads sont examiné à chaque passage. S’il y en a plus, il examinera
les 16 suivants à son prochain passage.
•
Le balance set manager limite le nombre de threads à accélérer à 10.
•
Un changement de contexte se produit à chaque ordonnancement et exige que l’on
mémorise :
– Pointeur d’instruction (compteur ordinal)
– Pointeurs de pile utilisateur et de pile noyau
– Pointeur vers l’espace d’adressage dans lequel est exécuté le thread (répertoire
des tables de pages du processus).
Génie Informatique
Chapitre 7.38
19
Implémentation
Ordonnanceur Nachos
#ifndef SCHEDULER_H
#define SCHEDULER_H
class Scheduler {
public:
Scheduler();
~Scheduler();
// Initialize list of ready threads
// De-allocate ready list
void ReadyToRun(Thread* thread); // Thread can be dispatched.
Thread* FindNextToRun(); // Dequeue first thread on the ready list, if any, and return thread.
void Run(Thread* nextThread, bool finishing); // Cause nextThread to start running
void CheckToBeDestroyed(); // Check if thread that had been running needs to be deleted
void Print();
// Print contents of ready list
private:
List<Thread *> *readyList; // queue of threads that are ready to run but not running
Thread *toBeDestroyed;
// finishing thread to be destroyed
// by the next thread that runs
};
#endif // SCHEDULER_H
Génie Informatique
Chapitre 7.39
Implémentation
Ordonnanceur Nachos (2)
Scheduler::Scheduler()
{ readyList = new List<Thread *>;
toBeDestroyed = NULL;
}
Scheduler::~Scheduler()
{ delete readyList;
}
void Scheduler::ReadyToRun (Thread *thread)
{
ASSERT(kernel->interrupt->getLevel() == IntOff);
DEBUG(dbgThread, "Putting thread on ready list: " << thread->getName());
thread->setStatus(READY);
readyList->Append(thread);
}
Génie Informatique
Chapitre 7.40
20
Implémentation
Thread * Scheduler::FindNextToRun ()
{ ASSERT(kernel->interrupt->getLevel() == IntOff);
if (readyList->IsEmpty())
return NULL;
else return readyList->RemoveFront();
}
void Scheduler::CheckToBeDestroyed()
{ if (toBeDestroyed != NULL)
{
delete toBeDestroyed;
toBeDestroyed = NULL;
}
}
void Scheduler::Print()
{ cout << "Ready list contents:\n";
readyList->Apply(ThreadPrint);
}
Génie Informatique
Chapitre 7.41
Implémentation
void Scheduler::Run (Thread *nextThread, bool finishing)
{ Thread *oldThread = kernel->currentThread;
if (finishing) {
// mark that we need to delete current thread
ASSERT(toBeDestroyed == NULL);
toBeDestroyed = oldThread;
}
#ifdef USER_PROGRAM
if (oldThread->space != NULL) {
oldThread->SaveUserState();
oldThread->space->SaveState();
}
#endif
// ignore until running user programs
// if this thread is a user program,
// save the user'
s CPU registers
oldThread->CheckOverflow(); // check if the old thread had an undetected stack overflow
Génie Informatique
Chapitre 7.42
21
Implémentation
kernel->currentThread = nextThread; // switch to the next thread
nextThread->setStatus(RUNNING);
// nextThread is now running
// This is a machine-dependent assembly language routine defined in switch.s.
SWITCH(oldThread, nextThread);
// interrupts are off when we return from switch!
CheckToBeDestroyed();
#ifdef USER_PROGRAM
if (oldThread->space != NULL) {
oldThread->RestoreUserState();
oldThread->space->RestoreState();
}
// check if thread we were running
// before this one has finished
// and needs to be cleaned up
// if there is an address space
// to restore, do it.
}
#endif
Génie Informatique
Chapitre 7.43
22

Ordonnancement de processus Introduction

Transcription

Documents pareils

TECHNICIEN(NE) EN GÉNIE CIVIL (Affectation temporaire

LE CV PAR COMPTENCES - Guide de Rédaction pour Ingénieur

dut génie biologie - iut lyon 1

INFORMATIQUE CYCLE PROBATOIRE GÉNIE LOGICIEL

dates de rentrée dut

de l`IUT de Vélizy - Université de V

L`extrait du casier judiciaire canadien (certificat de police) s`obtient à

Offre d`emploi

Quantum - Technicien en contrôle qualité

TECHNICIEN, TECHNICIENNE EN MÉCANIQUE DU BÂTIMENT